chrome: Use base::MessageLoop. (Part 3)

chrome/browser/extensions/extension_service_unittest.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/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 402 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 ExtensionServiceTestBase::ExtensionServiceInitParams::
 ExtensionServiceInitParams()
  : autoupdate_enabled(false), is_first_run(true) {
 }
 
 // Our message loop may be used in tests which require it to be an IO loop.
 ExtensionServiceTestBase::ExtensionServiceTestBase()
-    : loop_(MessageLoop::TYPE_IO),
+    : loop_(base::MessageLoop::TYPE_IO),
       service_(NULL),
       management_policy_(NULL),
       expected_extensions_count_(0),
       ui_thread_(BrowserThread::UI, &loop_),
       db_thread_(BrowserThread::DB, &loop_),
       webkit_thread_(BrowserThread::WEBKIT_DEPRECATED, &loop_),
       file_thread_(BrowserThread::FILE, &loop_),
       file_user_blocking_thread_(BrowserThread::FILE_USER_BLOCKING, &loop_),
       io_thread_(BrowserThread::IO, &loop_) {
   base::FilePath test_data_dir;
   if (!PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir)) {
     ADD_FAILURE();
     return;
   }
   data_dir_ = test_data_dir.AppendASCII("extensions");
 }
 
 ExtensionServiceTestBase::~ExtensionServiceTestBase() {
   // Drop our reference to ExtensionService and TestingProfile, so that they
   // can be destroyed while BrowserThreads and MessageLoop are still around
   // (they are used in the destruction process).
   service_ = NULL;
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   profile_.reset(NULL);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionService(
     const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
   TestingProfile::Builder profile_builder;
   // Create a PrefService that only contains user defined preference values.
   PrefServiceMockBuilder builder;
   builder.WithUserFilePrefs(
       params.pref_file, loop_.message_loop_proxy());
   scoped_refptr<PrefRegistrySyncable> registry(new PrefRegistrySyncable);
@@ skipping 656 matching lines @@
 // If packing succeeded, we make sure that the package names match our
 // expectations.
 void PackExtensionTestClient::OnPackSuccess(
     const base::FilePath& crx_path,
     const base::FilePath& private_key_path) {
   // We got the notification and processed it; we don't expect any further tasks
   // to be posted to the current thread, so we should stop blocking and continue
   // on with the rest of the test.
   // This call to |Quit()| matches the call to |Run()| in the
   // |PackPunctuatedExtension| test.
-  MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
   EXPECT_EQ(expected_crx_path_.value(), crx_path.value());
   EXPECT_EQ(expected_private_key_path_.value(), private_key_path.value());
   ASSERT_TRUE(file_util::PathExists(private_key_path));
 }
 
 // The tests are designed so that we never expect to see a packing error.
 void PackExtensionTestClient::OnPackFailure(const std::string& error_message,
                                             ExtensionCreator::ErrorType type) {
   if (type == ExtensionCreator::kCRXExists)
      FAIL() << "Packing should not fail.";
@@ skipping 878 matching lines @@
         new extensions::PackExtensionJob(&pack_client, output_dir,
                                          base::FilePath(),
                                          ExtensionCreator::kOverwriteCRX));
     packer->Start();
 
     // The packer will post a notification task to the current thread's message
     // loop when it is finished.  We manually run the loop here so that we
     // block and catch the notification; otherwise, the process would exit.
     // This call to |Run()| is matched by a call to |Quit()| in the
     // |PackExtensionTestClient|'s notification handling code.
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
 
     if (HasFatalFailure())
       return;
 
     InstallCRX(expected_crx_path, INSTALL_NEW);
   }
 }
 
 TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) {
   InitializeEmptyExtensionService();
@@ skipping 1763 matching lines @@
                            .AppendASCII("v2_bad_requirements");
   extensions::UnpackedInstaller::Create(service_)->Load(path);
   loop_.RunUntilIdle();
   EXPECT_EQ(1u, GetErrors().size());
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
 class ExtensionCookieCallback {
  public:
   ExtensionCookieCallback()
-    : result_(false),
-      weak_factory_(MessageLoop::current()) {}
+      : result_(false), weak_factory_(base::MessageLoop::current()) {}

[brettw, 2013/04/28 04:26:27]

In other cases you were a bit too aggressive putting things on separate lines
for function calls, but initializer lists should be on separate lines unless
everything (including the function name) fits on one, so the old way was better.

 
   void SetCookieCallback(bool result) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&MessageLoop::Quit, weak_factory_.GetWeakPtr()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,

[brettw, 2013/04/28 04:26:27]

Old way was fine, below also.

+        base::Bind(&base::MessageLoop::Quit, weak_factory_.GetWeakPtr()));
     result_ = result;
   }
 
   void GetAllCookiesCallback(const net::CookieList& list) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&MessageLoop::Quit, weak_factory_.GetWeakPtr()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&base::MessageLoop::Quit, weak_factory_.GetWeakPtr()));
     list_ = list;
   }
   net::CookieList list_;
   bool result_;
-  base::WeakPtrFactory<MessageLoop> weak_factory_;
+  base::WeakPtrFactory<base::MessageLoop> weak_factory_;
 };
 
 // Verifies extension state is removed upon uninstall.
 TEST_F(ExtensionServiceTest, ClearExtensionData) {
   InitializeEmptyExtensionService();
   ExtensionCookieCallback callback;
 
   // Load a test extension.
   base::FilePath path = data_dir_;
   path = path.AppendASCII("good.crx");
@@ skipping 796 matching lines @@
 //
 // Also tests that we always fire EXTENSIONS_READY, no matter whether we are
 // enabled or not.
 TEST(ExtensionServiceTestSimple, Enabledness) {
   // Make sure the PluginService singleton is destroyed at the end of the test.
   base::ShadowingAtExitManager at_exit_manager;
 
   ExtensionErrorReporter::Init(false);  // no noisy errors
   ExtensionsReadyRecorder recorder;
   scoped_ptr<TestingProfile> profile(new TestingProfile());
-  MessageLoop loop;
+  base::MessageLoop loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &loop);
   content::TestBrowserThread file_thread(BrowserThread::FILE, &loop);
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService device_settings_service;
   chromeos::ScopedTestCrosSettings cros_settings;
   scoped_ptr<chromeos::ScopedTestUserManager> user_manager(
       new chromeos::ScopedTestUserManager);
 #endif
   scoped_ptr<CommandLine> command_line;
   base::FilePath install_dir = profile->GetPath()
@@ skipping 1303 matching lines @@
       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
 
   service_->CheckForExternalUpdates();
   loop_.RunUntilIdle();
   EXPECT_TRUE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
 }