Don't register gmail users at the device management server

chrome/browser/policy/device_management_policy_provider_unittest.cc

 // Copyright (c) 2010 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 "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/mock_configuration_policy_store.h"
 #include "chrome/browser/policy/mock_device_management_backend.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/policy_constants.h"
 #include "chrome/test/mock_notification_observer.h"
+#include "chrome/test/testing_device_token_fetcher.h"
+#include "chrome/test/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const char kTestToken[] = "device_policy_provider_test_auth_token";
 
 namespace policy {
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Mock;
 
 class DeviceManagementPolicyProviderTest : public testing::Test {
  public:
   DeviceManagementPolicyProviderTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~DeviceManagementPolicyProviderTest() {}
 
   virtual void SetUp() {
-    EXPECT_TRUE(storage_dir_.CreateUniqueTempDir());
+    profile_.reset(new TestingProfile);
     CreateNewBackend();
     CreateNewProvider();
   }
 
   void CreateNewBackend() {
     backend_ = new MockDeviceManagementBackend;
   }
 
   void CreateNewProvider() {
-    token_service_.reset(new TokenService);
     provider_.reset(new DeviceManagementPolicyProvider(
         ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
         backend_,
-        token_service_.get(),
-        storage_dir_.path()));
+        profile_.get()));
+    provider_->SetDeviceTokenFetcher(
+        new TestingDeviceTokenFetcher(backend_,
+                                      profile_.get(),
+                                      provider_->GetTokenPath()));
     loop_.RunAllPending();
   }
 
   void SimulateSuccessfulLoginAndRunPending() {
     loop_.RunAllPending();
-    token_service_->IssueAuthTokenForTest(
+    profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kDeviceManagementService, kTestToken);
+    TestingDeviceTokenFetcher* fetcher =
+        static_cast<TestingDeviceTokenFetcher*>(
+            provider_->token_fetcher_.get());
+    fetcher->SimulateLogin(kTestManagedDomainUsername);
     loop_.RunAllPending();
   }
 
   void SimulateSuccessfulInitialPolicyFetch() {
     MockConfigurationPolicyStore store;
     EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedRegister());
     EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedBooleanPolicy(
             key::kDisableSpdy, true));
@@ skipping 21 matching lines @@
     provider->set_policy_refresh_rate_ms(policy_refresh_rate_ms);
     provider->set_policy_refresh_max_earlier_ms(policy_refresh_max_earlier_ms);
     provider->set_policy_refresh_error_delay_ms(policy_refresh_error_delay_ms);
     provider->set_token_fetch_error_delay_ms(token_fetch_error_delay_ms);
   }
 
  private:
   MessageLoop loop_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
-  ScopedTempDir storage_dir_;
-  scoped_ptr<TokenService> token_service_;
+  scoped_ptr<Profile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyProviderTest);
 };
 
 // If there's no login and no previously-fetched policy, the provider should
 // provide an empty policy.
 TEST_F(DeviceManagementPolicyProviderTest, InitialProvideNoLogin) {
   MockConfigurationPolicyStore store;
   EXPECT_CALL(store, Apply(_, _)).Times(0);
   provider_->Provide(&store);
@@ skipping 92 matching lines @@
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorRequestFailed));
   SimulateSuccessfulLoginAndRunPending();
 }
 
 }  // namespace policy