Correctly integrate StoragePartition into TestingProfile.

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/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 15 matching lines @@
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_syncable.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 "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_auth_consumer.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"
 
@@ skipping 21 matching lines @@
     "{"
     "  \"access_token\": \"5678\","
     "  \"expires_in\": 3600"
     "}";
 
 }  // namespace
 
 class UserCloudPolicyManagerChromeOSTest : public testing::Test {
  protected:
   UserCloudPolicyManagerChromeOSTest()
-      : ui_thread_(content::BrowserThread::UI, &loop_),
-        io_thread_(content::BrowserThread::IO, &loop_),
-        store_(NULL),
+      : store_(NULL),
         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());
     profile_ = profile_manager_->CreateTestingProfile(
         chrome::kInitialProfile, scoped_ptr<PrefServiceSyncable>(),
         UTF8ToUTF16("testing_profile"), 0);
-    signin_profile_ = profile_manager_->CreateTestingProfile("signin_profile");
+    signin_profile_ = profile_manager_->CreateTestingProfile(kSigninProfile);
     signin_profile_->set_incognito(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(signin_profile_);
     signin_profile_->SetOriginalProfile(profile_);
-    signin_profile_->CreateRequestContext();
     ASSERT_EQ(signin_profile_, chromeos::ProfileHelper::GetSigninProfile());
 
     chrome::RegisterLocalState(prefs_.registry());
 
     // Set up a policy map for testing.
     policy_map_.Set("HomepageLocation",
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                     base::Value::CreateStringValue("http://chromium.org"),
                     NULL);
     expected_bundle_.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
@@ skipping 18 matching lines @@
 
     EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(AnyNumber());
   }
 
   virtual void TearDown() OVERRIDE {
     if (manager_) {
       manager_->RemoveObserver(&observer_);
       manager_->Shutdown();
     }
-    signin_profile_->ResetRequestContext();
+    signin_profile_ = NULL;
+    profile_ = NULL;
+    profile_manager_->DeleteTestingProfile(kSigninProfile);
+    profile_manager_->DeleteTestingProfile(chrome::kInitialProfile);
   }
 
   void CreateManager(bool wait_for_fetch) {
     store_ = new MockCloudPolicyStore();
     EXPECT_CALL(*store_, Load());
     manager_.reset(new UserCloudPolicyManagerChromeOS(
         scoped_ptr<CloudPolicyStore>(store_),
         scoped_ptr<ResourceCache>(),
         wait_for_fetch));
     manager_->Init();
@@ skipping 108 matching lines @@
     // Notifying that the store is has cached the fetched policy completes the
     // process, and initializes the manager.
     EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
     store_->policy_map_.CopyFrom(policy_map_);
     store_->NotifyStoreLoaded();
     EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
     Mock::VerifyAndClearExpectations(&observer_);
     EXPECT_TRUE(manager_->policies().Equals(expected_bundle_));
   }
 
-  // Required by the refresh scheduler that's created by the manager.
-  base::MessageLoop loop_;
-  content::TestBrowserThread ui_thread_;
-  // Required to cleanup the URLRequestContextGetter of the |signin_profile_|.
-  content::TestBrowserThread io_thread_;
+  // Required by the refresh scheduler that's created by the manager and
+  // for the cleanup of URLRequestContextGetter in the |signin_profile_|.
+  content::TestBrowserThreadBundle thread_bundle_;
 
   // Convenience policy objects.
   em::PolicyData policy_data_;
   em::DeviceManagementResponse register_blob_;
   em::DeviceManagementResponse policy_blob_;
   PolicyMap policy_map_;
   PolicyBundle expected_bundle_;
 
   // Policy infrastructure.
   net::TestURLFetcherFactory test_url_fetcher_factory_;
   TestingPrefServiceSimple prefs_;
   MockConfigurationPolicyObserver observer_;
   MockDeviceManagementService device_management_service_;
   MockCloudPolicyStore* store_;
   scoped_ptr<UserCloudPolicyManagerChromeOS> manager_;
   scoped_ptr<UserCloudPolicyTokenForwarder> token_forwarder_;
 
   // Required by ProfileHelper to get the signin Profile context.
   scoped_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;
   TestingProfile* signin_profile_;
 
+  static const char kSigninProfile[];
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyManagerChromeOSTest);
 };
 
+const char UserCloudPolicyManagerChromeOSTest::kSigninProfile[] =
+    "signin_profile";
+
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFirstFetch) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the policy cache is empty.
   ASSERT_NO_FATAL_FAILURE(CreateManager(true));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreLoaded();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
@@ skipping 202 matching lines @@
 
   // The refresh scheduler takes care of the initial fetch for unmanaged users.
   // It posts a delayed task with 0ms delay in this case, so spinning the loop
   // issues the initial fetch.
   base::RunLoop loop;
   FetchPolicy(
       base::Bind(&base::RunLoop::RunUntilIdle, base::Unretained(&loop)));
 }
 
 }  // namespace policy