1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86


ash / ambient / ambient_access_token_controller.h [blame]

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ASH_AMBIENT_AMBIENT_ACCESS_TOKEN_CONTROLLER_H_
#define ASH_AMBIENT_AMBIENT_ACCESS_TOKEN_CONTROLLER_H_

#include <string>
#include <vector>

#include "ash/ambient/ambient_constants.h"
#include "ash/ash_export.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "google_apis/gaia/gaia_id.h"
#include "net/base/backoff_entry.h"

namespace ash {

// A class to manage the access token for ambient mode. Request will be async
// and will be returned as soon as the token is refreshed. If the token has
// already been refreshed, request call will be returned immediately.
class ASH_EXPORT AmbientAccessTokenController {
 public:
  using AccessTokenCallback =
      base::OnceCallback<void(const GaiaId& gaia_id,
                              const std::string& access_token)>;

  AmbientAccessTokenController();
  AmbientAccessTokenController(const AmbientAccessTokenController&) = delete;
  AmbientAccessTokenController& operator=(const AmbientAccessTokenController&) =
      delete;
  ~AmbientAccessTokenController();

  // The caller will pass in a preference |may_refresh_token_on_lock| whether
  // to refresh token on lock screen when it expires. In current implementation,
  // the AmbientController will request token once the screen is locked. This is
  // allowed (We could make the request before screen is locked, then the logic
  // in AmbientAccessTokenController could be simpler, i.e. just check if the
  // lock screen is on or not). Future requests on lock screen can not refresh
  // token if it expires.
  void RequestAccessToken(AccessTokenCallback callback,
                          bool may_refresh_token_on_lock = false);

  base::WeakPtr<AmbientAccessTokenController> AsWeakPtr();

 private:
  friend class AmbientAshTestBase;

  void RefreshAccessToken();
  void AccessTokenRefreshed(const GaiaId& gaia_id,
                            const std::string& access_token,
                            const base::Time& expiration_time);
  void RetryRefreshAccessToken();
  void NotifyAccessTokenRefreshed();
  void RunCallback(AccessTokenCallback callback);

  void SetTokenUsageBufferForTesting(base::TimeDelta time);

  base::TimeDelta GetTimeUntilReleaseForTesting();

  GaiaId gaia_id_;
  std::string access_token_;

  // The expiration time of the |access_token_|.
  base::Time expiration_time_;

  // True if has already sent access token request and waiting for result.
  bool has_pending_request_ = false;

  // The buffer time to use the access token.
  base::TimeDelta token_usage_time_buffer_ = kTokenUsageTimeBuffer;

  base::OneShotTimer token_refresh_timer_;

  net::BackoffEntry refresh_token_retry_backoff_;

  std::vector<AccessTokenCallback> callbacks_;

  base::WeakPtrFactory<AmbientAccessTokenController> weak_factory_{this};
};

}  // namespace ash

#endif  // ASH_AMBIENT_AMBIENT_ACCESS_TOKEN_CONTROLLER_H_