Revert 173477

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,
-        const base::Callback<void(const std::string&)>& callback,
+        IBusControllerImpl* controller,
         IBusAddressWatcher* watcher)
         : ibus_address_(ibus_address),
-          callback_(callback),
+          controller_(controller),
           watcher_(watcher) {
       DCHECK(watcher);
       DCHECK(!ibus_address.empty());
     }
 
     virtual void OnFilePathChanged(const FilePath& file_path) OVERRIDE {
       if (!watcher_->IsWatching())
         return;
-      callback_.Run(ibus_address_);
+      bool success = content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(
+              &IBusControllerImpl::IBusDaemonInitializationDone,
+              controller_,
+              ibus_address_));
+      DCHECK(success);
       watcher_->StopSoon();
     }
 
    protected:
     virtual ~IBusAddressFileWatcherDelegate() {}
 
    private:
     // The ibus-daemon address.
     const std::string ibus_address_;
-    base::Callback<void(const std::string&)> callback_;
+    IBusControllerImpl* controller_;
     IBusAddressWatcher* watcher_;
 
     DISALLOW_COPY_AND_ASSIGN(IBusAddressFileWatcherDelegate);
   };
 
   static void Start(const std::string& ibus_address,
-                    const base::Callback<void(const std::string&)>& callback) {
+                    IBusControllerImpl* controller) {
     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, callback, instance);
+        new IBusAddressFileWatcherDelegate(ibus_address, controller, 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(
-    const scoped_refptr<base::SequencedTaskRunner>& default_task_runner,
-    const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner)
+IBusControllerImpl::IBusControllerImpl()
     : 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 195 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.
-
-  // 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(
+  bool success = content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(&IBusAddressWatcher::Start, ibus_daemon_address_, callback),
+      base::Bind(&IBusAddressWatcher::Start,
+                 ibus_daemon_address_,
+                 base::Unretained(this)),
       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);
   }
 }
 
-void IBusControllerImpl::IBusDaemonInitializationDoneWorkerCallback(
+// static
+void IBusControllerImpl::IBusDaemonInitializationDone(
+    IBusControllerImpl* controller,
     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(
-    const std::string& ibus_address) {
-  if (ibus_daemon_address_ != ibus_address)
+  if (controller->ibus_daemon_address_ != ibus_address)
     return;
 
-  if (ibus_daemon_status_ != IBUS_DAEMON_INITIALIZING) {
+  if (controller->ibus_daemon_status_ != IBUS_DAEMON_INITIALIZING) {
     // Stop() or OnIBusDaemonExit() has already been called.
     return;
   }
   chromeos::DBusThreadManager::Get()->InitIBusBus(ibus_address);
-  ibus_daemon_status_ = IBUS_DAEMON_RUNNING;
+  controller->ibus_daemon_status_ = IBUS_DAEMON_RUNNING;
 
-  ui::InputMethodIBus* input_method_ibus = GetInputMethod();
+  ui::InputMethodIBus* input_method_ibus = controller->GetInputMethod();
   DCHECK(input_method_ibus);
   input_method_ibus->OnConnected();
 
-  DBusThreadManager::Get()->GetIBusPanelService()->SetUpPropertyHandler(this);
+  DBusThreadManager::Get()->GetIBusPanelService()->SetUpPropertyHandler(
+      controller);
 
   // Restore previous input method at the beggining of connection.
-  if (!current_input_method_id_.empty())
-    SendChangeInputMethodRequest(current_input_method_id_);
+  if (!controller->current_input_method_id_.empty()) {
+    controller->SendChangeInputMethodRequest(
+        controller->current_input_method_id_);
+  }
 
   DBusThreadManager::Get()->GetIBusConfigClient()->InitializeAsync(
       base::Bind(&IBusControllerImpl::OnIBusConfigClientInitialized,
-                 weak_ptr_factory_.GetWeakPtr()));
+                 controller->weak_ptr_factory_.GetWeakPtr()));
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnConnected());
+  FOR_EACH_OBSERVER(Observer, controller->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