Add enterprise enrollment support for fake users.

chrome/browser/chromeos/policy/policy_oauth2_token_fetcher.cc

 // Copyright (c) 2013 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/chromeos/policy/policy_oauth2_token_fetcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 13 matching lines @@
 namespace {
 
 // Max retry count for token fetching requests.
 const int kMaxRequestAttemptCount = 5;
 
 // OAuth token request retry delay in milliseconds.
 const int kRequestRestartDelay = 3000;
 
 }  // namespace
 
+bool PolicyOAuth2TokenFetcher::enable_fake_for_testing_ = false;

[achuithb, 2016/03/03 22:45:00]

do we use comment //static here? I think we do?

[jdufault, 2016/03/04 20:42:47]

Done.

+
 PolicyOAuth2TokenFetcher::PolicyOAuth2TokenFetcher() {
 }
 
 PolicyOAuth2TokenFetcher::~PolicyOAuth2TokenFetcher() {
 }
 
 void PolicyOAuth2TokenFetcher::StartWithSigninContext(
     net::URLRequestContextGetter* auth_context_getter,
     net::URLRequestContextGetter* system_context_getter,
     const TokenCallback& callback) {
   DCHECK(!refresh_token_fetcher_ && !access_token_fetcher_);
 
   auth_context_getter_ = auth_context_getter;
   system_context_getter_ = system_context_getter;
   callback_ = callback;
+
+  if (enable_fake_for_testing_) {

[achuithb, 2016/03/03 22:45:00]

Rather than pollute this class, is it possible to create a
PolicyOAuth2TokenFetcherTest class or something, and create instances of that
class instead of this one?

[jdufault, 2016/03/03 23:11:04]

Sure; I will have to make PolicyOAuth2TokenFetcher an interface though, and move
all of the code from this file into PolicyOAuth2TokenFetcherImpl. The fake will
then be PolicyOAuth2TokenFetcherFake.

[achuithb, 2016/03/03 23:23:43]

I think that would be cleaner?

[achuithb, 2016/03/04 19:12:37]

Or maybe this is too much work for not much gain.

Maybe create a helper like ReturnFakeTokenForTesting and call that instead.

Also, enable_fake_for_testing_ sounds incomplete. Maybe
fake_authcode_for_testing_? Or a better name if you can think of one

[jdufault, 2016/03/04 20:42:47]

Done. Also moved the impl header file to the cc file so the h file is much
cleaner now.

+    OnGetTokenSuccess("authcode",
+                      base::Time::Now() + base::TimeDelta::FromMinutes(5));
+    return;
+  }
+
   StartFetchingRefreshToken();
 }
 
 void PolicyOAuth2TokenFetcher::StartWithAuthCode(
     const std::string& auth_code,
     net::URLRequestContextGetter* system_context_getter,
     const TokenCallback& callback) {
   DCHECK(!refresh_token_fetcher_ && !access_token_fetcher_);
 
   auth_code_ = auth_code;
   system_context_getter_ = system_context_getter;
   callback_ = callback;
+
+  if (enable_fake_for_testing_) {
+    OnGetTokenSuccess("authcode",
+                      base::Time::Now() + base::TimeDelta::FromMinutes(5));
+    return;
+  }
+
   StartFetchingRefreshToken();
 }
 
 void PolicyOAuth2TokenFetcher::StartWithRefreshToken(
     const std::string& oauth2_refresh_token,
     net::URLRequestContextGetter* system_context_getter,
     const TokenCallback& callback) {
   DCHECK(!refresh_token_fetcher_ && !access_token_fetcher_);
 
   oauth2_refresh_token_ = oauth2_refresh_token;
   system_context_getter_ = system_context_getter;
   callback_ = callback;
+
+  if (enable_fake_for_testing_) {
+    OnGetTokenSuccess("authcode",
+                      base::Time::Now() + base::TimeDelta::FromMinutes(5));
+    return;
+  }
+
   StartFetchingAccessToken();
 }
 
 void PolicyOAuth2TokenFetcher::StartFetchingRefreshToken() {
   if (auth_code_.empty()) {
     refresh_token_fetcher_.reset(new GaiaAuthFetcher(
         this, GaiaConstants::kChromeSource, auth_context_getter_.get()));
     refresh_token_fetcher_->StartCookieForOAuthLoginTokenExchange(
         std::string());
   } else {
@@ skipping 10 matching lines @@
   access_token_fetcher_.reset(
       new OAuth2AccessTokenFetcherImpl(this,
                                        system_context_getter_.get(),
                                        oauth2_refresh_token_));
   access_token_fetcher_->Start(
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
       scopes);
 }
 
+void PolicyOAuth2TokenFetcher::EnableFakeForTesting() {
+  enable_fake_for_testing_ = true;
+}
+
 void PolicyOAuth2TokenFetcher::OnClientOAuthSuccess(
     const GaiaAuthConsumer::ClientOAuthResult& oauth2_tokens) {
   VLOG(1) << "OAuth2 tokens for policy fetching succeeded.";
   oauth2_refresh_token_ = oauth2_tokens.refresh_token;
   retry_count_ = 0;
   StartFetchingAccessToken();
 }
 
 void PolicyOAuth2TokenFetcher::OnClientOAuthFailure(
     const GoogleServiceAuthError& error) {
@@ skipping 41 matching lines @@
 }
 
 void PolicyOAuth2TokenFetcher::ForwardPolicyToken(
     const std::string& token,
     const GoogleServiceAuthError& error) {
   if (!callback_.is_null())
     callback_.Run(token, error);
 }
 
 }  // namespace policy