Remove FILE thread dependency in protocol_handler_registry_unittest.cc

chrome/browser/custom_handlers/protocol_handler_registry_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/custom_handlers/protocol_handler_registry.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_renderer_host.h"
 #include "net/base/request_priority.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
@@ skipping 90 matching lines @@
 std::unique_ptr<base::DictionaryValue> GetProtocolHandlerValueWithDefault(
     const std::string& protocol,
     const std::string& url,
     bool is_default) {
   std::unique_ptr<base::DictionaryValue> value =
       GetProtocolHandlerValue(protocol, url);
   value->SetBoolean("default", is_default);
   return value;
 }
 
-class FakeProtocolClientWorker
-    : public shell_integration::DefaultProtocolClientWorker {
- public:
-  FakeProtocolClientWorker(
-      const shell_integration::DefaultWebClientWorkerCallback& callback,
-      const std::string& protocol,
-      bool force_failure)
-      : shell_integration::DefaultProtocolClientWorker(callback, protocol),
-        force_failure_(force_failure) {}
-
- private:
-  ~FakeProtocolClientWorker() override = default;
-
-  shell_integration::DefaultWebClientState CheckIsDefaultImpl() override {
-    return force_failure_ ? shell_integration::NOT_DEFAULT
-                          : shell_integration::IS_DEFAULT;
-  }
-
-  void SetAsDefaultImpl(const base::Closure& on_finished_callback) override {
-    on_finished_callback.Run();
-  }
-
- private:
-  bool force_failure_;
-};
-
 class FakeDelegate : public ProtocolHandlerRegistry::Delegate {
  public:
   FakeDelegate() : force_os_failure_(false) {}
   ~FakeDelegate() override {}
   void RegisterExternalHandler(const std::string& protocol) override {
     ASSERT_TRUE(
         registered_protocols_.find(protocol) == registered_protocols_.end());
     registered_protocols_.insert(protocol);
   }
 
   void DeregisterExternalHandler(const std::string& protocol) override {
     registered_protocols_.erase(protocol);
   }
 
-  scoped_refptr<shell_integration::DefaultProtocolClientWorker>
-  CreateShellWorker(
-      const shell_integration::DefaultWebClientWorkerCallback& callback,
-      const std::string& protocol) override {
-    return new FakeProtocolClientWorker(callback, protocol, force_os_failure_);
-  }
-
   void RegisterWithOSAsDefaultClient(
       const std::string& protocol,
-      ProtocolHandlerRegistry* registry) override;
+      ProtocolHandlerRegistry* registry) override {
+    // Do as-if the registration has to run on another sequence and post back
+    // the result with a task to the current thread.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(registry->GetDefaultWebClientCallback(protocol),
+                   force_os_failure_ ? shell_integration::NOT_DEFAULT
+                                     : shell_integration::IS_DEFAULT));
+
+    if (!force_os_failure_)
+      os_registered_protocols_.insert(protocol);
+  }
 
   bool IsExternalHandlerRegistered(const std::string& protocol) override {
     return registered_protocols_.find(protocol) != registered_protocols_.end();
   }
 
   bool IsFakeRegisteredWithOS(const std::string& protocol) {
     return os_registered_protocols_.find(protocol) !=
         os_registered_protocols_.end();
   }
 
-  void FakeRegisterWithOS(const std::string& protocol) {
-    os_registered_protocols_.insert(protocol);
-  }
-
   void Reset() {
     registered_protocols_.clear();
     os_registered_protocols_.clear();
     force_os_failure_ = false;
   }
 
   void set_force_os_failure(bool force) { force_os_failure_ = force; }
 
   bool force_os_failure() { return force_os_failure_; }
 
  private:
   std::set<std::string> registered_protocols_;
   std::set<std::string> os_registered_protocols_;
   bool force_os_failure_;
 };
 
-void OnShellWorkerFinished(ProtocolHandlerRegistry* registry,
-                           FakeDelegate* delegate,
-                           const std::string& protocol,
-                           shell_integration::DefaultWebClientState state) {
-  registry->GetDefaultWebClientCallback(protocol).Run(state);
-  if (state == shell_integration::IS_DEFAULT) {
-    delegate->FakeRegisterWithOS(protocol);
-  }
-
-  base::MessageLoop::current()->QuitWhenIdle();
-}
-
-void FakeDelegate::RegisterWithOSAsDefaultClient(
-    const std::string& protocol,
-    ProtocolHandlerRegistry* registry) {
-  // The worker pointer is reference counted. While it is running, the
-  // message loops of the FILE and UI thread will hold references to it
-  // and it will be automatically freed once all its tasks have finished.
-  CreateShellWorker(base::Bind(OnShellWorkerFinished, registry, this, protocol),
-                    protocol)
-      ->StartSetAsDefault();
-  ASSERT_FALSE(IsFakeRegisteredWithOS(protocol));
-}
-
 class NotificationCounter : public content::NotificationObserver {
  public:
   explicit NotificationCounter(content::BrowserContext* context)
       : events_(0),
         notification_registrar_() {
     notification_registrar_.Add(this,
         chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
             content::Source<content::BrowserContext>(context));
   }
 
@@ skipping 29 matching lines @@
     std::vector<std::string> output;
     local_registry_->GetRegisteredProtocols(&output);
     called_ = true;
   }
 
   ProtocolHandlerRegistry* local_registry_;
   bool called_;
   content::NotificationRegistrar notification_registrar_;
 };
 
-// URLRequest DCHECKS that the current MessageLoop is IO. It does this because
-// it can't check the thread id (since net can't depend on content.) We want
-// to harness our tests so all threads use the same loop allowing us to
-// guarantee all messages are processed.) By overriding the IsType method
-// we basically ignore the supplied message loop type, and instead infer
-// our type based on the current thread. GO DEPENDENCY INJECTION!
-class TestMessageLoop : public base::MessageLoop {
- public:
-  TestMessageLoop() {}
-  ~TestMessageLoop() override {}
-  bool IsType(base::MessageLoop::Type type) const override {
-    switch (type) {
-      case base::MessageLoop::TYPE_UI:
-        return BrowserThread::CurrentlyOn(BrowserThread::UI);
-      case base::MessageLoop::TYPE_IO:
-        return BrowserThread::CurrentlyOn(BrowserThread::IO);
-#if defined(OS_ANDROID)
-      case base::MessageLoop::TYPE_JAVA:  // fall-through
-#endif  // defined(OS_ANDROID)
-      case base::MessageLoop::TYPE_CUSTOM:
-      case base::MessageLoop::TYPE_DEFAULT:
-        return !BrowserThread::CurrentlyOn(BrowserThread::UI) &&
-               !BrowserThread::CurrentlyOn(BrowserThread::IO);
-    }
-    return false;
-  }
-};
-
 }  // namespace
 
 class ProtocolHandlerRegistryTest : public testing::Test {
  protected:
   ProtocolHandlerRegistryTest()
-  : ui_thread_(BrowserThread::UI, &loop_),
-    file_thread_(BrowserThread::FILE, &loop_),
-    io_thread_(BrowserThread::IO, &loop_),
-    test_protocol_handler_(CreateProtocolHandler("test", "test")) {}
+      : test_protocol_handler_(CreateProtocolHandler("test", "test")) {}
 
   FakeDelegate* delegate() const { return delegate_; }
   ProtocolHandlerRegistry* registry() { return registry_.get(); }
   TestingProfile* profile() const { return profile_.get(); }
   const ProtocolHandler& test_protocol_handler() const {
     return test_protocol_handler_;
   }
 
   ProtocolHandler CreateProtocolHandler(const std::string& protocol,
                                         const GURL& url) {
@@ skipping 57 matching lines @@
   void SetUp() override {
     profile_.reset(new TestingProfile());
     CHECK(profile_->GetPrefs());
     SetUpRegistry(true);
     test_protocol_handler_ =
         CreateProtocolHandler("test", GURL("http://test.com/%s"));
   }
 
   void TearDown() override { TeadDownRegistry(); }
 
-  TestMessageLoop loop_;
-
  private:
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
-  content::TestBrowserThread io_thread_;
+  content::TestBrowserThreadBundle test_browser_thread_bundle_;
 
   std::unique_ptr<TestingProfile> profile_;
   FakeDelegate* delegate_;  // Registry assumes ownership of delegate_.
   std::unique_ptr<ProtocolHandlerRegistry> registry_;
   ProtocolHandler test_protocol_handler_;
 };
 
 TEST_F(ProtocolHandlerRegistryTest, AcceptProtocolHandlerHandlesProtocol) {
   ASSERT_FALSE(registry()->IsHandledProtocol("test"));
   registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler());
@@ skipping 309 matching lines @@
 TEST_F(ProtocolHandlerRegistryTest, TestOSRegistration) {
   ProtocolHandler ph_do1 = CreateProtocolHandler("do", "test1");
   ProtocolHandler ph_do2 = CreateProtocolHandler("do", "test2");
   ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test");
 
   ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("do"));
   ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont"));
 
   registry()->OnAcceptRegisterProtocolHandler(ph_do1);
   registry()->OnDenyRegisterProtocolHandler(ph_dont);
-  base::RunLoop().Run();  // FILE thread needs to run.
+  base::RunLoop().RunUntilIdle();
+
   ASSERT_TRUE(delegate()->IsFakeRegisteredWithOS("do"));
   ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont"));
 
   // This should not register with the OS, if it does the delegate
   // will assert for us. We don't need to wait for the message loop
   // as it should not go through to the shell worker.
   registry()->OnAcceptRegisterProtocolHandler(ph_do2);
 }
 
 #if defined(OS_LINUX)
 // TODO(benwells): When Linux support is more reliable and
 // http://crbug.com/88255 is fixed this test will pass.
 #define MAYBE_TestOSRegistrationFailure DISABLED_TestOSRegistrationFailure
 #else
 #define MAYBE_TestOSRegistrationFailure TestOSRegistrationFailure
 #endif
 
 // TODO(smckay): This is much more appropriately an integration
 // test. Make that so, then update the
 // ShellIntegretion{Delegate,Callback,Worker} test classes we use to fully
 // isolate this test from the FILE thread.
 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestOSRegistrationFailure) {
   ProtocolHandler ph_do = CreateProtocolHandler("do", "test1");
   ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test");
 
   ASSERT_FALSE(registry()->IsHandledProtocol("do"));
   ASSERT_FALSE(registry()->IsHandledProtocol("dont"));
 
   registry()->OnAcceptRegisterProtocolHandler(ph_do);
-  base::RunLoop().Run();  // FILE thread needs to run.
+  base::RunLoop().RunUntilIdle();
+
   delegate()->set_force_os_failure(true);
   registry()->OnAcceptRegisterProtocolHandler(ph_dont);
-  base::RunLoop().Run();  // FILE thread needs to run.
+  base::RunLoop().RunUntilIdle();
+
   ASSERT_TRUE(registry()->IsHandledProtocol("do"));
   ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("do").size());
   ASSERT_FALSE(registry()->IsHandledProtocol("dont"));
   ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("dont").size());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestMaybeCreateTaskWorksFromIOThread) {
   ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   GURL url("mailto:someone@something.com");
@@ skipping 294 matching lines @@
   // added to pref.
   ASSERT_EQ(InPrefIgnoredHandlerCount(), 2);
   ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4);
 
   registry()->RemoveIgnoredHandler(p2u1);
 
   // p2u1 installed by user and policy, so it is removed from pref alone.
   ASSERT_EQ(InPrefIgnoredHandlerCount(), 1);
   ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4);
 }