[Extensions] Make chrome://extensions use management.uninstall

chrome/browser/extensions/extension_service_test_base.cc

 // Copyright 2014 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_test_base.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 15 matching lines @@
 #include "extensions/browser/extension_registry.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/extensions/install_limiter.h"
 #endif
 
 namespace extensions {
 
 namespace {
 
+// By default, we run on the IO loop.
+const int kThreadOptions = content::TestBrowserThreadBundle::IO_MAINLOOP;

[not at google - send to devlin, 2015/02/25 21:37:57]

UI thread makes more sense for a default test thread. Very few functions live on
the IO thread.

[Devlin, 2015/02/25 23:12:47]

But breaks tons of other stuff, as discussed offline. Leaving like this for now.

+
 // Create a testing profile according to |params|.
 scoped_ptr<TestingProfile> BuildTestingProfile(
     const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
   TestingProfile::Builder profile_builder;
   // Create a PrefService that only contains user defined preference values.
   PrefServiceMockFactory factory;
   // If pref_file is empty, TestingProfile automatically creates
   // TestingPrefServiceSyncable instance.
   if (!params.pref_file.empty()) {
     factory.SetUserPrefsFile(params.pref_file,
@@ skipping 15 matching lines @@
 
 }  // namespace
 
 ExtensionServiceTestBase::ExtensionServiceInitParams::
     ExtensionServiceInitParams()
     : autoupdate_enabled(false),
       is_first_run(true),
       profile_is_supervised(false) {
 }
 
-// Our message loop may be used in tests which require it to be an IO loop.
 ExtensionServiceTestBase::ExtensionServiceTestBase()
     : service_(NULL),
-      thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+      thread_bundle_(new content::TestBrowserThreadBundle(kThreadOptions)),
+      did_reset_thread_bundle_(false),
       registry_(NULL) {
   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() {
+  // Parts of destruction have to happen on an IO thread, so if the thread
+  // bundle is reset, we need to change it back.
+  if (did_reset_thread_bundle_)
+    ResetThreadBundle(kThreadOptions);
+
   // Why? Because |profile_| has to be destroyed before |at_exit_manager_|, but
   // is declared above it in the class definition since it's protected.
   profile_.reset();
 }
 
 ExtensionServiceTestBase::ExtensionServiceInitParams
 ExtensionServiceTestBase::CreateDefaultInitParams() {
   ExtensionServiceInitParams params;
   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path = temp_dir_.path();
@@ skipping 68 matching lines @@
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
   ExtensionServiceInitParams params = CreateDefaultInitParams();
   params.autoupdate_enabled = true;
   InitializeExtensionService(params);
   service_->updater()->Start();
 }
 
+void ExtensionServiceTestBase::ResetThreadBundle(int options) {
+  did_reset_thread_bundle_ = true;
+  thread_bundle_.reset();
+  thread_bundle_.reset(new content::TestBrowserThreadBundle(options));
+}
+
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 void ExtensionServiceTestBase::SetUpTestCase() {
   // Safe to call multiple times.
   ExtensionErrorReporter::Init(false);  // no noisy errors.
 }
 
 // These are declared in the .cc so that all inheritors don't need to know
@@ skipping 33 matching lines @@
   // interfere with the tests. Those tests that need an external provider
   // will register one specifically.
   service_->ClearProvidersForTesting();
 
 #if defined(OS_CHROMEOS)
   InstallLimiter::Get(profile_.get())->DisableForTest();
 #endif
 }
 
 }  // namespace extensions