Decouple input_method from BrowserThread (and content/).

chrome/browser/chromeos/input_method/ibus_controller_impl.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/input_method/ibus_controller_impl.h"
 
 #include <algorithm>  // for std::reverse.
 #include <cstdio>
 #include <cstring>  // for std::strcmp.
 #include <set>
 #include <sstream>
 #include <stack>
 #include <utility>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/files/file_path_watcher.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
+#include "base/sequenced_task_runner.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/chromeos/input_method/input_method_config.h"
 #include "chrome/browser/chromeos/input_method/input_method_property.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/ibus/ibus_client.h"
 #include "chromeos/dbus/ibus/ibus_config_client.h"
 #include "chromeos/dbus/ibus/ibus_constants.h"
 #include "chromeos/dbus/ibus/ibus_input_context_client.h"
 #include "chromeos/dbus/ibus/ibus_panel_service.h"
 #include "chromeos/dbus/ibus/ibus_property.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/ime/input_method_ibus.h"
 
 namespace {
 
 // Finds a property which has |new_prop.key| from |prop_list|, and replaces the
 // property with |new_prop|. Returns true if such a property is found.
 bool FindAndUpdateProperty(
     const chromeos::input_method::InputMethodProperty& new_prop,
@@ skipping 141 matching lines @@
   return result;
 }
 
 class IBusAddressWatcher {
  public:
   class IBusAddressFileWatcherDelegate
       : public base::files::FilePathWatcher::Delegate {
    public:
     IBusAddressFileWatcherDelegate(
         const std::string& ibus_address,
-        IBusControllerImpl* controller,
+        const base::Callback<void(const std::string&)>& callback,
         IBusAddressWatcher* watcher)
         : ibus_address_(ibus_address),
-          controller_(controller),
+          callback_(callback),
           watcher_(watcher) {
       DCHECK(watcher);
       DCHECK(!ibus_address.empty());
     }
 
     virtual void OnFilePathChanged(const FilePath& file_path) OVERRIDE {
       if (!watcher_->IsWatching())
         return;
-      bool success = content::BrowserThread::PostTask(
-          content::BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(
-              &IBusControllerImpl::IBusDaemonInitializationDone,
-              controller_,
-              ibus_address_));
-      DCHECK(success);
+      callback_.Run(ibus_address_);
       watcher_->StopSoon();
     }
 
    protected:
     virtual ~IBusAddressFileWatcherDelegate() {}
 
    private:
     // The ibus-daemon address.
     const std::string ibus_address_;
-    IBusControllerImpl* controller_;
+    base::Callback<void(const std::string&)> callback_;
     IBusAddressWatcher* watcher_;
 
     DISALLOW_COPY_AND_ASSIGN(IBusAddressFileWatcherDelegate);
   };
 
   static void Start(const std::string& ibus_address,
-                    IBusControllerImpl* controller) {
+                    const base::Callback<void(const std::string&)>& callback) {
     IBusAddressWatcher* instance = IBusAddressWatcher::Get();
     scoped_ptr<base::Environment> env(base::Environment::Create());
     std::string address_file_path;
     // TODO(nona): move reading environment variables to UI thread.
     env->GetVar("IBUS_ADDRESS_FILE", &address_file_path);
     DCHECK(!address_file_path.empty());
 
     if (instance->IsWatching())
       instance->StopNow();
     instance->watcher_ = new base::files::FilePathWatcher;
 
     // The |delegate| is owned by watcher.
     IBusAddressFileWatcherDelegate* delegate =
-        new IBusAddressFileWatcherDelegate(ibus_address, controller, instance);
+        new IBusAddressFileWatcherDelegate(ibus_address, callback, instance);
     bool result = instance->watcher_->Watch(FilePath(address_file_path),
                                             delegate);
     DCHECK(result);
   }
 
   void StopNow() {
     delete watcher_;
     watcher_ = NULL;
   }
 
   void StopSoon() {
     if (!watcher_)
       return;
     MessageLoop::current()->DeleteSoon(FROM_HERE, watcher_);
     watcher_ = NULL;
   }
 
   bool IsWatching() const {
     return watcher_ != NULL;
   }
 
  private:
   static IBusAddressWatcher* Get() {
     static IBusAddressWatcher* instance = new IBusAddressWatcher;
-    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
     return instance;
   }
 
   // Singleton
   IBusAddressWatcher()
       :  watcher_(NULL) {}
   base::files::FilePathWatcher* watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(IBusAddressWatcher);
 };
 
 }  // namespace
 
-IBusControllerImpl::IBusControllerImpl()
+IBusControllerImpl::IBusControllerImpl(
+    const scoped_refptr<base::SequencedTaskRunner>& default_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner)
     : process_handle_(base::kNullProcessHandle),
       ibus_daemon_status_(IBUS_DAEMON_STOP),
       input_method_(NULL),
+      default_task_runner_(default_task_runner),
+      worker_task_runner_(worker_task_runner),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 IBusControllerImpl::~IBusControllerImpl() {
 }
 
 bool IBusControllerImpl::Start() {
   if (IBusConnectionsAreAlive())
     return true;
   if (ibus_daemon_status_ == IBUS_DAEMON_STOP ||
@@ skipping 206 matching lines @@
   }
 
   ibus_daemon_status_ = IBUS_DAEMON_INITIALIZING;
   ibus_daemon_address_ = base::StringPrintf(
       "unix:abstract=ibus-%d",
       base::RandInt(0, std::numeric_limits<int>::max()));
 
   // Set up ibus-daemon address file watcher before launching ibus-daemon,
   // because if watcher starts after ibus-daemon, we may miss the ibus
   // connection initialization.
-  bool success = content::BrowserThread::PostTaskAndReply(
-      content::BrowserThread::FILE,
+
+  // Create a callback to bounce from the worker thread to the default thread.
+  base::Callback<void(const std::string&)> callback(base::Bind(
+      &IBusControllerImpl::IBusDaemonInitializationDoneWorkerCallback,
+      weak_ptr_factory_.GetWeakPtr()));
+
+  bool success = worker_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&IBusAddressWatcher::Start,
-                 ibus_daemon_address_,
-                 base::Unretained(this)),
+      base::Bind(&IBusAddressWatcher::Start, ibus_daemon_address_, callback),
       base::Bind(&IBusControllerImpl::LaunchIBusDaemon,
                  weak_ptr_factory_.GetWeakPtr(),
                  ibus_daemon_address_));
   DCHECK(success);
   return true;
 }
 
 void IBusControllerImpl::LaunchIBusDaemon(const std::string& ibus_address) {
   DCHECK_EQ(base::kNullProcessHandle, process_handle_);
   static const char kIBusDaemonPath[] = "/usr/bin/ibus-daemon";
@@ skipping 47 matching lines @@
 }
 
 void IBusControllerImpl::OnIBusConfigClientInitialized() {
   InputMethodConfigRequests::const_iterator iter =
       current_config_values_.begin();
   for (; iter != current_config_values_.end(); ++iter) {
     SetInputMethodConfigInternal(iter->first, iter->second);
   }
 }
 
-// static
+void IBusControllerImpl::IBusDaemonInitializationDoneWorkerCallback(
+    const std::string& ibus_address) {
+  bool result = default_task_runner_->PostTask(FROM_HERE, base::Bind(
+      &IBusControllerImpl::IBusDaemonInitializationDone,
+      weak_ptr_factory_.GetWeakPtr(),
+      ibus_address));
+  DCHECK(result);
+}
+
 void IBusControllerImpl::IBusDaemonInitializationDone(
-    IBusControllerImpl* controller,
     const std::string& ibus_address) {
-  if (controller->ibus_daemon_address_ != ibus_address)
+  if (ibus_daemon_address_ != ibus_address)
     return;
 
-  if (controller->ibus_daemon_status_ != IBUS_DAEMON_INITIALIZING) {
+  if (ibus_daemon_status_ != IBUS_DAEMON_INITIALIZING) {
     // Stop() or OnIBusDaemonExit() has already been called.
     return;
   }
   chromeos::DBusThreadManager::Get()->InitIBusBus(ibus_address);
-  controller->ibus_daemon_status_ = IBUS_DAEMON_RUNNING;
+  ibus_daemon_status_ = IBUS_DAEMON_RUNNING;
 
-  ui::InputMethodIBus* input_method_ibus = controller->GetInputMethod();
+  ui::InputMethodIBus* input_method_ibus = GetInputMethod();
   DCHECK(input_method_ibus);
   input_method_ibus->OnConnected();
 
-  DBusThreadManager::Get()->GetIBusPanelService()->SetUpPropertyHandler(
-      controller);
+  DBusThreadManager::Get()->GetIBusPanelService()->SetUpPropertyHandler(this);
 
   // Restore previous input method at the beggining of connection.
-  if (!controller->current_input_method_id_.empty()) {
-    controller->SendChangeInputMethodRequest(
-        controller->current_input_method_id_);
-  }
+  if (!current_input_method_id_.empty())
+    SendChangeInputMethodRequest(current_input_method_id_);
 
   DBusThreadManager::Get()->GetIBusConfigClient()->InitializeAsync(
       base::Bind(&IBusControllerImpl::OnIBusConfigClientInitialized,
-                 controller->weak_ptr_factory_.GetWeakPtr()));
+                 weak_ptr_factory_.GetWeakPtr()));
 
-  FOR_EACH_OBSERVER(Observer, controller->observers_, OnConnected());
+  FOR_EACH_OBSERVER(Observer, observers_, OnConnected());
 
   VLOG(1) << "The ibus-daemon initialization is done.";
 }
 
 // static
 void IBusControllerImpl::OnIBusDaemonExit(GPid pid,
                                           gint status,
                                           IBusControllerImpl* controller) {
   if (controller->process_handle_ != base::kNullProcessHandle) {
     if (base::GetProcId(controller->process_handle_) == pid) {
@@ skipping 30 matching lines @@
 
 // static
 bool IBusControllerImpl::FindAndUpdatePropertyForTesting(
     const chromeos::input_method::InputMethodProperty& new_prop,
     chromeos::input_method::InputMethodPropertyList* prop_list) {
   return FindAndUpdateProperty(new_prop, prop_list);
 }
 
 }  // namespace input_method
 }  // namespace chromeos