xref: /external/chromium_org/chrome/browser/signin/easy_unlock_toggle_flow.cc

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

#include "chrome/browser/signin/easy_unlock_toggle_flow.h"

#include <vector>

#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
#include "chrome/browser/signin/signin_manager_factory.h"
#include "chrome/common/extensions/api/identity/oauth2_manifest_handler.h"
#include "chrome/common/extensions/extension_constants.h"
#include "components/signin/core/browser/profile_oauth2_token_service.h"
#include "components/signin/core/browser/signin_manager.h"
#include "extensions/browser/extension_system.h"
#include "google_apis/gaia/oauth2_api_call_flow.h"
#include "net/url_request/url_fetcher.h"

namespace {

const char kEasyUnlockToggleUrl[] =
    "https://www.googleapis.com/cryptauth/v1/deviceSync/toggleeasyunlock";

std::vector<std::string> GetScopes() {
  std::vector<std::string> scopes;
  scopes.push_back("https://www.googleapis.com/auth/proximity_auth");
  scopes.push_back("https://www.googleapis.com/auth/cryptauth");
  return scopes;
}

std::string GetEasyUnlockAppClientId(Profile * profile) {
  extensions::ExtensionSystem* extension_system =
      extensions::ExtensionSystem::Get(profile);
  ExtensionService* extension_service = extension_system->extension_service();
  const extensions::Extension* easy_unlock_app =
      extension_service->GetInstalledExtension(
          extension_misc::kEasyUnlockAppId);
  if (!easy_unlock_app)
    return std::string();

  const extensions::OAuth2Info& oauth2_info =
      extensions::OAuth2Info::GetOAuth2Info(easy_unlock_app);
  return oauth2_info.client_id;
}

}  // namespace

class EasyUnlockToggleFlow::ToggleApiCall : public OAuth2ApiCallFlow {
 public:
  ToggleApiCall(EasyUnlockToggleFlow* flow,
                net::URLRequestContextGetter* context,
                const std::string& access_token,
                const std::string& phone_public_key,
                bool toggle_enable);
  virtual ~ToggleApiCall();

  // OAuth2ApiCallFlow
  virtual GURL CreateApiCallUrl() OVERRIDE;
  virtual std::string CreateApiCallBody() OVERRIDE;
  virtual std::string CreateApiCallBodyContentType() OVERRIDE;
  virtual void ProcessApiCallSuccess(const net::URLFetcher* source) OVERRIDE;
  virtual void ProcessApiCallFailure(const net::URLFetcher* source) OVERRIDE;
  virtual void ProcessNewAccessToken(const std::string& access_token) OVERRIDE;
  virtual void ProcessMintAccessTokenFailure(
      const GoogleServiceAuthError& error) OVERRIDE;

 private:
  EasyUnlockToggleFlow* flow_;
  const std::string phone_public_key_;
  const bool toggle_enable_;

  DISALLOW_COPY_AND_ASSIGN(ToggleApiCall);
};

EasyUnlockToggleFlow::ToggleApiCall::ToggleApiCall(
    EasyUnlockToggleFlow* flow,
    net::URLRequestContextGetter* context,
    const std::string& access_token,
    const std::string& phone_public_key,
    bool toggle_enable)
    : OAuth2ApiCallFlow(context,
                        std::string(),
                        access_token,
                        GetScopes()),
      flow_(flow),
      phone_public_key_(phone_public_key),
      toggle_enable_(toggle_enable) {
}

EasyUnlockToggleFlow::ToggleApiCall::~ToggleApiCall() {
}

GURL EasyUnlockToggleFlow::ToggleApiCall::CreateApiCallUrl() {
  return GURL(kEasyUnlockToggleUrl);
}

std::string EasyUnlockToggleFlow::ToggleApiCall::CreateApiCallBody() {
  const char kBodyFormat[] = "{\"enable\":%s,\"publicKey\":\"%s\"}";
  return base::StringPrintf(
      kBodyFormat,
      toggle_enable_ ? "true" : "false",
      phone_public_key_.c_str());
}

std::string
EasyUnlockToggleFlow::ToggleApiCall::CreateApiCallBodyContentType() {
  return "application/json";
}

void EasyUnlockToggleFlow::ToggleApiCall::ProcessApiCallSuccess(
    const net::URLFetcher* source) {
  flow_->ReportToggleApiCallResult(true);
}

void EasyUnlockToggleFlow::ToggleApiCall::ProcessApiCallFailure(
    const net::URLFetcher* source) {
  flow_->ReportToggleApiCallResult(false);
}

void EasyUnlockToggleFlow::ToggleApiCall::ProcessNewAccessToken(
    const std::string& access_token) {
  NOTREACHED();
}

void EasyUnlockToggleFlow::ToggleApiCall::ProcessMintAccessTokenFailure(
    const GoogleServiceAuthError& error) {
  NOTREACHED();
}

EasyUnlockToggleFlow::EasyUnlockToggleFlow(Profile* profile,
                                           const std::string& phone_public_key,
                                           bool toggle_enable,
                                           const ToggleFlowCallback& callback)
    : OAuth2TokenService::Consumer("easy_unlock_toggle"),
      profile_(profile),
      phone_public_key_(phone_public_key),
      toggle_enable_(toggle_enable),
      callback_(callback) {
}

EasyUnlockToggleFlow::~EasyUnlockToggleFlow() {
}

void EasyUnlockToggleFlow::Start() {
  ProfileOAuth2TokenService* token_service =
      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
  SigninManagerBase* signin_manager =
      SigninManagerFactory::GetForProfile(profile_);
  token_request_ =
      token_service->StartRequest(signin_manager->GetAuthenticatedAccountId(),
                                  OAuth2TokenService::ScopeSet(),
                                  this);
}

void EasyUnlockToggleFlow::OnGetTokenSuccess(
    const OAuth2TokenService::Request* request,
    const std::string& access_token,
    const base::Time& expiration_time) {
  DCHECK_EQ(token_request_.get(), request);
  token_request_.reset();

  mint_token_flow_.reset(
      new OAuth2MintTokenFlow(profile_->GetRequestContext(),
                              this,
                              OAuth2MintTokenFlow::Parameters(
                                  access_token,
                                  extension_misc::kEasyUnlockAppId,
                                  GetEasyUnlockAppClientId(profile_),
                                  GetScopes(),
                                  OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE)));
  mint_token_flow_->Start();
}

void EasyUnlockToggleFlow::OnGetTokenFailure(
    const OAuth2TokenService::Request* request,
    const GoogleServiceAuthError& error) {
  DCHECK_EQ(token_request_.get(), request);
  token_request_.reset();

  LOG(ERROR) << "Easy unlock toggle flow, failed to get access token,"
             << "error=" << error.state();
  callback_.Run(false);
}

void EasyUnlockToggleFlow::OnMintTokenSuccess(const std::string& access_token,
                                              int time_to_live) {
  toggle_api_call_.reset(new ToggleApiCall(this,
                                           profile_->GetRequestContext(),
                                           access_token,
                                           phone_public_key_,
                                           toggle_enable_));
  toggle_api_call_->Start();
}

void EasyUnlockToggleFlow::OnMintTokenFailure(
    const GoogleServiceAuthError& error) {
  LOG(ERROR) << "Easy unlock toggle flow, failed to mint access token,"
             << "error=" << error.state();
  callback_.Run(false);
}

void EasyUnlockToggleFlow::OnIssueAdviceSuccess(
    const IssueAdviceInfo& issue_advice) {
  NOTREACHED();
}

void EasyUnlockToggleFlow::ReportToggleApiCallResult(bool success) {
  callback_.Run(success);
}