Decouple input_method from BrowserThread (and content/).

chrome/browser/chromeos/input_method/xkeyboard.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/xkeyboard.h"
 
 #include <cstdlib>
 #include <cstring>
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
+#include "base/sequenced_task_runner.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/base/x/x11_util.h"
 
 // These includes conflict with base/tracked_objects.h so must come last.
 #include <X11/XKBlib.h>
 #include <X11/Xlib.h>
 #include <glib.h>
 
-using content::BrowserThread;
-
 namespace chromeos {
 namespace input_method {
 namespace {
 
 // The default keyboard layout name in the xorg config file.
 const char kDefaultLayoutName[] = "us";
 
 // The command we use to set the current XKB layout and modifier key mapping.
 // TODO(yusukes): Use libxkbfile.so instead of the command (crosbug.com/13105)
 const char kSetxkbmapCommand[] = "/usr/bin/setxkbmap";
@@ skipping 15 matching lines @@
       std::string::npos) {
     DVLOG(1) << "Invalid layout_name: " << layout_name;
     return false;
   }
 
   return true;
 }
 
 class XKeyboardImpl : public XKeyboard {
  public:
-  explicit XKeyboardImpl(const InputMethodUtil& util);
+  explicit XKeyboardImpl(
+      const InputMethodUtil& util,
+      const scoped_refptr<base::SequencedTaskRunner>& default_task_runner);
   virtual ~XKeyboardImpl() {}
 
   // Overridden from XKeyboard:
   virtual bool SetCurrentKeyboardLayoutByName(
       const std::string& layout_name) OVERRIDE;
   virtual bool ReapplyCurrentKeyboardLayout() OVERRIDE;
   virtual void ReapplyCurrentModifierLockStatus() OVERRIDE;
   virtual void SetLockedModifiers(
       ModifierLockStatus new_caps_lock_status,
       ModifierLockStatus new_num_lock_status) OVERRIDE;
   virtual void SetNumLockEnabled(bool enable_num_lock) OVERRIDE;
   virtual void SetCapsLockEnabled(bool enable_caps_lock) OVERRIDE;
   virtual bool NumLockIsEnabled() OVERRIDE;
   virtual bool CapsLockIsEnabled() OVERRIDE;
   virtual unsigned int GetNumLockMask() OVERRIDE;
   virtual void GetLockedModifiers(bool* out_caps_lock_enabled,
                                   bool* out_num_lock_enabled) OVERRIDE;
+  virtual bool SetAutoRepeatEnabled(bool enabled) OVERRIDE;
+  virtual bool SetAutoRepeatRate(const AutoRepeatRate& rate) OVERRIDE;
 
  private:
   // This function is used by SetLayout() and RemapModifierKeys(). Calls
   // setxkbmap command if needed, and updates the last_full_layout_name_ cache.
   bool SetLayoutInternal(const std::string& layout_name, bool force);
 
   // Executes 'setxkbmap -layout ...' command asynchronously using a layout name
   // in the |execute_queue_|. Do nothing if the queue is empty.
   // TODO(yusukes): Use libxkbfile.so instead of the command (crosbug.com/13105)
   void MaybeExecuteSetLayoutCommand();
@@ skipping 10 matching lines @@
 
   // The current Num Lock and Caps Lock status. If true, enabled.
   bool current_num_lock_status_;
   bool current_caps_lock_status_;
   // The XKB layout name which we set last time like "us" and "us(dvorak)".
   std::string current_layout_name_;
 
   // A queue for executing setxkbmap one by one.
   std::queue<std::string> execute_queue_;
 
+  scoped_refptr<base::SequencedTaskRunner> default_task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(XKeyboardImpl);
 };
 
-XKeyboardImpl::XKeyboardImpl(const InputMethodUtil& util)
-    : is_running_on_chrome_os_(base::chromeos::IsRunningOnChromeOS()) {
+XKeyboardImpl::XKeyboardImpl(
+    const InputMethodUtil& util,
+    const scoped_refptr<base::SequencedTaskRunner>& default_task_runner)
+    : is_running_on_chrome_os_(base::chromeos::IsRunningOnChromeOS()),
+      default_task_runner_(default_task_runner) {
   num_lock_mask_ = GetNumLockMask();
 
   // web_input_event_aurax11.cc seems to assume that Mod2Mask is always assigned
   // to Num Lock.
   // TODO(yusukes): Check the assumption is really okay. If not, modify the Aura
   // code, and then remove the CHECK below.
   CHECK(!is_running_on_chrome_os_ || (num_lock_mask_ == Mod2Mask));
   GetLockedModifiers(&current_caps_lock_status_, &current_num_lock_status_);
 }
 
@@ skipping 182 matching lines @@
 
 bool XKeyboardImpl::CurrentlyOnUIThread() const {
   // It seems that the tot Chrome (as of Mar 7 2012) does not allow browser
   // tests to call BrowserThread::CurrentlyOn(). It ends up a CHECK failure:
   //   FATAL:sequenced_worker_pool.cc
   //   Check failed: constructor_message_loop_.get().
   // For now, just allow unit/browser tests to call any functions in this class.
   // TODO(yusukes): Stop special-casing browser_tests and remove this function.
   if (!is_running_on_chrome_os_)
     return true;
-  return BrowserThread::CurrentlyOn(BrowserThread::UI);
+  return default_task_runner_->RunsTasksOnCurrentThread();
 }
 
 // static
 void XKeyboardImpl::OnSetLayoutFinish(pid_t pid,
                                       int status,
                                       XKeyboardImpl* self) {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(self->default_task_runner_->RunsTasksOnCurrentThread());
   DVLOG(1) << "OnSetLayoutFinish: pid=" << pid;
   if (self->execute_queue_.empty()) {
     DVLOG(1) << "OnSetLayoutFinish: execute_queue_ is empty. "
              << "base::LaunchProcess failed? pid=" << pid;
     return;
   }
   self->execute_queue_.pop();
   self->MaybeExecuteSetLayoutCommand();
 }
 
-}  // namespace
-
-// static
-bool XKeyboard::SetAutoRepeatEnabled(bool enabled) {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+bool XKeyboardImpl::SetAutoRepeatEnabled(bool enabled) {
+  CHECK(default_task_runner_->RunsTasksOnCurrentThread());
   if (enabled)
     XAutoRepeatOn(ui::GetXDisplay());
   else
     XAutoRepeatOff(ui::GetXDisplay());
   DVLOG(1) << "Set auto-repeat mode to: " << (enabled ? "on" : "off");
   return true;
 }
 
-// static
-bool XKeyboard::SetAutoRepeatRate(const AutoRepeatRate& rate) {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+bool XKeyboardImpl::SetAutoRepeatRate(const AutoRepeatRate& rate) {
+  CHECK(default_task_runner_->RunsTasksOnCurrentThread());
   DVLOG(1) << "Set auto-repeat rate to: "
            << rate.initial_delay_in_ms << " ms delay, "
            << rate.repeat_interval_in_ms << " ms interval";
   if (XkbSetAutoRepeatRate(ui::GetXDisplay(), XkbUseCoreKbd,
                            rate.initial_delay_in_ms,
                            rate.repeat_interval_in_ms) != True) {
     DVLOG(1) << "Failed to set auto-repeat rate";
     return false;
   }
   return true;
 }
 
+}  // namespace
+
 // static
 bool XKeyboard::GetAutoRepeatEnabledForTesting() {
   XKeyboardState state = {};
   XGetKeyboardControl(ui::GetXDisplay(), &state);
   return state.global_auto_repeat != AutoRepeatModeOff;
 }
 
 // static
 bool XKeyboard::GetAutoRepeatRateForTesting(AutoRepeatRate* out_rate) {
   return XkbGetAutoRepeatRate(ui::GetXDisplay(), XkbUseCoreKbd,
                               &(out_rate->initial_delay_in_ms),
                               &(out_rate->repeat_interval_in_ms)) == True;
 }
 
 // static
 bool XKeyboard::CheckLayoutNameForTesting(const std::string& layout_name) {
   return CheckLayoutName(layout_name);
 }
 
 // static
-XKeyboard* XKeyboard::Create(const InputMethodUtil& util) {
-  return new XKeyboardImpl(util);
+XKeyboard* XKeyboard::Create(
+    const InputMethodUtil& util,
+    const scoped_refptr<base::SequencedTaskRunner>& default_task_runner) {
+  return new XKeyboardImpl(util, default_task_runner);
 }
 
 }  // namespace input_method
 }  // namespace chromeos