This is the fourth CL of several that will eventually replace TokenService with

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc

 // Copyright (c) 2012 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/user_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_token_forwarder.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/policy/cloud/cloud_external_data_manager.h"
 #include "chrome/browser/policy/cloud/mock_cloud_external_data_manager.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/mock_device_management_service.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/policy/schema_registry.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
-#include "chrome/browser/signin/signin_manager.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/signin/token_service.h"
-#include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_auth_consumer.h"
+#include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace em = enterprise_management;
 
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Mock;
 using testing::_;
 
 namespace policy {
 
 namespace {
 
 const char kOAuthTokenCookie[] = "oauth_token=1234";
+const char kTestAccountId[] = "user@gmail.com";
 
 const char kOAuth2TokenPairData[] =
     "{"
     "  \"refresh_token\": \"1234\","
     "  \"access_token\": \"5678\","
     "  \"expires_in\": 3600"
     "}";
 
 const char kOAuth2AccessTokenData[] =
     "{"
@@ skipping 11 matching lines @@
         task_runner_(new base::TestSimpleTaskRunner()),
         profile_(NULL),
         signin_profile_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     // The initialization path that blocks on the initial policy fetch requires
     // a signin Profile to use its URLRequestContext.
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
+    TestingProfile::TestingFactories factories;
+    factories.push_back(
+        std::make_pair(ProfileOAuth2TokenServiceFactory::GetInstance(),
+                       FakeProfileOAuth2TokenService::Build));
     profile_ = profile_manager_->CreateTestingProfile(
         chrome::kInitialProfile, scoped_ptr<PrefServiceSyncable>(),
-        UTF8ToUTF16("testing_profile"), 0, std::string());
+        UTF8ToUTF16("testing_profile"), 0, std::string(), factories);
     signin_profile_ = profile_manager_->CreateTestingProfile(kSigninProfile);
     signin_profile_->ForceIncognito(true);
     // Usually the signin Profile and the main Profile are separate, but since
     // the signin Profile is an OTR Profile then for this test it suffices to
     // attach it to the main Profile.
     profile_->SetOffTheRecordProfile(scoped_ptr<Profile>(signin_profile_));
     signin_profile_->SetOriginalProfile(profile_);
     ASSERT_EQ(signin_profile_, chromeos::ProfileHelper::GetSigninProfile());
 
     chrome::RegisterLocalState(prefs_.registry());
@@ skipping 88 matching lines @@
     fetcher->set_response_code(200);
     fetcher->set_status(net::URLRequestStatus());
     return fetcher;
   }
 
   // Issues the OAuth2 tokens and returns the device management register job
   // if the flow succeeded.
   MockDeviceManagementJob* IssueOAuthToken(bool has_request_token) {
     EXPECT_FALSE(manager_->core()->client()->is_registered());
 
-    GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
-    net::TestURLFetcher* fetcher = NULL;
+    // Issuing this token triggers the callback of the OAuth2PolicyFetcher,
+    // which triggers the registration request.
+    MockDeviceManagementJob* register_request = NULL;
+    EXPECT_CALL(device_management_service_,
+                CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
+        .WillOnce(device_management_service_.CreateAsyncJob(&register_request));
 
     if (!has_request_token) {
+      GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
+      net::TestURLFetcher* fetcher = NULL;
+
       // Issue the oauth_token cookie first.
       fetcher = PrepareOAuthFetcher(gaia_urls->client_login_to_oauth2_url());
       if (!fetcher)
         return NULL;
       net::ResponseCookies cookies;
       cookies.push_back(kOAuthTokenCookie);
       fetcher->set_cookies(cookies);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
 
       // Issue the refresh token.
       fetcher = PrepareOAuthFetcher(gaia_urls->oauth2_token_url());
       if (!fetcher)
         return NULL;
       fetcher->SetResponseString(kOAuth2TokenPairData);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+      // Issue the access token.
+      fetcher = PrepareOAuthFetcher(gaia_urls->oauth2_token_url());
+      if (!fetcher)
+        return NULL;
+      fetcher->SetResponseString(kOAuth2AccessTokenData);
+      fetcher->delegate()->OnURLFetchComplete(fetcher);
+    } else {
+      // Since the refresh token is available, OAuth2TokenService was used
+      // to request the access token and not UserCloudPolicyTokenForwarder.
+      // Issue the access token with the former.
+      FakeProfileOAuth2TokenService* token_service =
+        static_cast<FakeProfileOAuth2TokenService*>(
+            ProfileOAuth2TokenServiceFactory::GetForProfile(profile_));
+      EXPECT_TRUE(token_service);
+      OAuth2TokenService::ScopeSet scopes;
+      scopes.insert(GaiaConstants::kDeviceManagementServiceOAuth);
+      token_service->IssueTokenForScope(
+          scopes, "5678",
+          base::Time::Now() + base::TimeDelta::FromSeconds(3600));
     }
 
-    // Issue the access token.
-    fetcher = PrepareOAuthFetcher(gaia_urls->oauth2_token_url());
-    if (!fetcher)
-      return NULL;
-    fetcher->SetResponseString(kOAuth2AccessTokenData);
-
-    // Issuing this token triggers the callback of the OAuth2PolicyFetcher,
-    // which triggers the registration request.
-    MockDeviceManagementJob* register_request = NULL;
-    EXPECT_CALL(device_management_service_,
-                CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
-        .WillOnce(device_management_service_.CreateAsyncJob(&register_request));
-    fetcher->delegate()->OnURLFetchComplete(fetcher);
     EXPECT_TRUE(register_request);
     EXPECT_FALSE(manager_->core()->client()->is_registered());
 
     Mock::VerifyAndClearExpectations(&device_management_service_);
     EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(AnyNumber());
 
     return register_request;
   }
 
@@ skipping 253 matching lines @@
   store_->NotifyStoreLoaded();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // The manager is waiting for the refresh token, and hasn't started any
   // fetchers.
   EXPECT_FALSE(test_url_fetcher_factory_.GetFetcherByID(0));
 
-  // Set a fake user in signin manager.  This can be removed once TokenService
-  // is removed.
-  SigninManagerBase* signin_manager =
-      SigninManagerFactory::GetForProfile(profile_);
-  ASSERT_TRUE(signin_manager);
-  signin_manager->SetAuthenticatedUsername("user@gmail.com");
-
-  // Set a fake refresh token at the TokenService.
-  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
+  // Set a fake refresh token at the OAuth2TokenService.
+  FakeProfileOAuth2TokenService* token_service =
+    static_cast<FakeProfileOAuth2TokenService*>(
+        ProfileOAuth2TokenServiceFactory::GetForProfile(profile_));
   ASSERT_TRUE(token_service);
-  GaiaAuthConsumer::ClientOAuthResult tokens("refresh", "access", 3600);
-  EXPECT_FALSE(token_service->HasOAuthLoginToken());
-  token_service->UpdateCredentialsWithOAuth2(tokens);
-  EXPECT_TRUE(token_service->HasOAuthLoginToken());
+  EXPECT_FALSE(token_service->RefreshTokenIsAvailable(kTestAccountId));
+  token_service->IssueRefreshToken(kTestAccountId);
+  EXPECT_TRUE(token_service->RefreshTokenIsAvailable(kTestAccountId));
 
   // That should have notified the manager, which now issues the request for the
   // policy oauth token.
   MockDeviceManagementJob* register_request = IssueOAuthToken(true);
   ASSERT_TRUE(register_request);
   register_request->SendResponse(DM_STATUS_SUCCESS, register_blob_);
 
   // The refresh scheduler takes care of the initial fetch for unmanaged users.
   // Running the task runner issues the initial fetch.
   FetchPolicy(
@@ skipping 17 matching lines @@
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(manager_->core()->client()->is_registered());
 
   // The refresh scheduler takes care of the initial fetch for unmanaged users.
   // Running the task runner issues the initial fetch.
   FetchPolicy(
       base::Bind(&base::TestSimpleTaskRunner::RunUntilIdle, task_runner_));
 }
 
 }  // namespace policy