Ensure tests have an active task runner

chrome/browser/extensions/extension_special_storage_policy_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 "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 using extensions::ExtensionSet;
 using extensions::Manifest;
@@ skipping 142 matching lines @@
     const ExtensionSet* extensions = policy_->ExtensionsProtectingOrigin(url);
     EXPECT_EQ(expected_extensions.size(), extensions->size());
     for (ExtensionSet::const_iterator it = expected_extensions.begin();
          it != expected_extensions.end(); ++it) {
       EXPECT_TRUE(extensions->Contains((*it)->id()))
           << "Origin " << url << "not protected by extension ID "
           << (*it)->id();
     }
   }
 
+  content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<ExtensionSpecialStoragePolicy> policy_;
 };
 
 TEST_F(ExtensionSpecialStoragePolicyTest, EmptyPolicy) {
   const GURL kHttpUrl("http://foo");
   const GURL kExtensionUrl("chrome-extension://bar");
   scoped_refptr<Extension> app(CreateRegularApp());
 
   EXPECT_FALSE(policy_->IsStorageUnlimited(kHttpUrl));
   EXPECT_FALSE(policy_->IsStorageUnlimited(kHttpUrl));  // test cached result
@@ skipping 117 matching lines @@
   ExpectProtectedBy(protecting_extensions, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://bar.wildcards/"));
 
   policy_->RevokeRightsForExtension(protected_app.get());
   ExpectProtectedBy(empty_set, GURL("http://explicit/"));
   ExpectProtectedBy(empty_set, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("https://bar.wildcards/"));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, HasSessionOnlyOrigins) {
-  base::MessageLoop message_loop;
-  content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
-
   TestingProfile profile;
   CookieSettings* cookie_settings =
       CookieSettings::Factory::GetForProfile(&profile).get();
   policy_ = new ExtensionSpecialStoragePolicy(cookie_settings);
 
   EXPECT_FALSE(policy_->HasSessionOnlyOrigins());
 
   // The default setting can be session-only.
   cookie_settings->SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
   EXPECT_TRUE(policy_->HasSessionOnlyOrigins());
@@ skipping 12 matching lines @@
   EXPECT_TRUE(policy_->HasSessionOnlyOrigins());
 
   // Clearing an origin-specific rule.
   cookie_settings->ResetCookieSetting(pattern,
                                       ContentSettingsPattern::Wildcard());
 
   EXPECT_FALSE(policy_->HasSessionOnlyOrigins());
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, NotificationTest) {
-  base::MessageLoop message_loop;
-  content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
-  content::TestBrowserThread io_thread(BrowserThread::IO, &message_loop);
-
   PolicyChangeObserver observer;
   policy_->AddObserver(&observer);
 
   scoped_refptr<Extension> apps[] = {
     CreateProtectedApp(),
     CreateUnlimitedApp(),
   };
 
   int change_flags[] = {
     SpecialStoragePolicy::STORAGE_PROTECTED,
 
     SpecialStoragePolicy::STORAGE_PROTECTED |
     SpecialStoragePolicy::STORAGE_UNLIMITED,
   };
 
   ASSERT_EQ(arraysize(apps), arraysize(change_flags));
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     observer.ExpectGrant(apps[i]->id(), change_flags[i]);
     policy_->GrantRightsForExtension(apps[i].get(), NULL);
-    message_loop.RunUntilIdle();
+    base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     policy_->GrantRightsForExtension(apps[i].get(), NULL);
-    message_loop.RunUntilIdle();
+    base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     observer.ExpectRevoke(apps[i]->id(), change_flags[i]);
     policy_->RevokeRightsForExtension(apps[i].get());
-    message_loop.RunUntilIdle();
+    base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     policy_->RevokeRightsForExtension(apps[i].get());
-    message_loop.RunUntilIdle();
+    base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   observer.ExpectClear();
   policy_->RevokeRightsForAllExtensions();
-  message_loop.RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(observer.IsCompleted());
 
   policy_->RemoveObserver(&observer);
 }