Introduce bypass logic for SetCursorLocation message.

chromeos/dbus/ibus/ibus_input_context_client.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 "chromeos/dbus/ibus/ibus_input_context_client.h"
 
 #include <string>
 #include "base/bind.h"
 #include "base/callback.h"
 #include "chromeos/dbus/ibus/ibus_constants.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace chromeos {
 
 // TODO(nona): Remove after complete libibus removal.
 using chromeos::ibus::IBusText;
 
 namespace {
 
 // The IBusInputContextClient implementation.
 class IBusInputContextClientImpl : public IBusInputContextClient {
  public:
   IBusInputContextClientImpl()
       : proxy_(NULL),
+        is_xkb_layout_(true),
         weak_ptr_factory_(this) {
   }
 
   virtual ~IBusInputContextClientImpl() {}
 
  public:
   // IBusInputContextClient override.
   virtual void Initialize(dbus::Bus* bus,
                           const dbus::ObjectPath& object_path) OVERRIDE {
     if (proxy_ != NULL) {
       LOG(ERROR) << "IBusInputContextClient is already initialized.";
       return;
     }
     proxy_ = bus->GetObjectProxy(ibus::kServiceName, object_path);
 
     ConnectSignals();
   }
 
   // IBusInputContextClient override.
   virtual void SetInputContextHandler(
       IBusInputContextHandlerInterface* handler) OVERRIDE {
     handler_ = handler;
   }
 
   // IBusInputContextClient override.
+  virtual void SetSetCursorLocationHandler(
+      const SetCursorLocationHandler& set_cursor_location_handler) OVERRIDE {
+    DCHECK(!set_cursor_location_handler.is_null());
+    set_cursor_location_handler_ = set_cursor_location_handler;
+  }
+
+  // IBusInputContextClient override.
+  virtual void UnsetSetCursorLocationHandler() OVERRIDE {
+    set_cursor_location_handler_.Reset();
+  }
+
+  // IBusInputContextClient override.
   virtual void ResetObjectProxy() OVERRIDE {
     // Do not delete proxy here, proxy object is managed by dbus::Bus object.
     proxy_ = NULL;
   }
 
   // IBusInputContextClient override.
   virtual bool IsObjectProxyReady() const OVERRIDE {
     return proxy_ != NULL;
   }
 
@@ skipping 22 matching lines @@
   }
 
   // IBusInputContextClient override.
   virtual void Reset() OVERRIDE {
     dbus::MethodCall method_call(ibus::input_context::kServiceInterface,
                                  ibus::input_context::kResetMethod);
     CallNoResponseMethod(&method_call, ibus::input_context::kResetMethod);
   }
 
   // IBusInputContextClient override.
-  virtual void SetCursorLocation(int32 x, int32 y, int32 width,
-                                 int32 height) OVERRIDE {
-    dbus::MethodCall method_call(ibus::input_context::kServiceInterface,
-                                 ibus::input_context::kSetCursorLocationMethod);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendInt32(x);
-    writer.AppendInt32(y);
-    writer.AppendInt32(width);
-    writer.AppendInt32(height);
-    CallNoResponseMethod(&method_call,
-                         ibus::input_context::kSetCursorLocationMethod);
+  virtual void SetCursorLocation(const ibus::Rect& cursor_location,
+                                 const ibus::Rect& composition_head) OVERRIDE {
+    if (!set_cursor_location_handler_.is_null())
+      set_cursor_location_handler_.Run(cursor_location, composition_head);
   }
 
   // IBusInputContextClient override.
   virtual void ProcessKeyEvent(
       uint32 keyval,
       uint32 keycode,
       uint32 state,
       const ProcessKeyEventCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(ibus::input_context::kServiceInterface,
@@ skipping 35 matching lines @@
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(key);
     if (state == ibus::IBUS_PROPERTY_STATE_CHECKED) {
       writer.AppendUint32(ibus::IBUS_PROPERTY_STATE_CHECKED);
     } else {
       writer.AppendUint32(ibus::IBUS_PROPERTY_STATE_UNCHECKED);
     }
     CallNoResponseMethod(&method_call,
                          ibus::input_context::kPropertyActivateMethod);
   }
+
+  // IBusInputContextClient override.
+  virtual bool IsXKBLayout() OVERRIDE {
+    return is_xkb_layout_;
+  }
+
+  // IBusInputContextClient override.
+  virtual void SetIsXKBLayout(bool is_xkb_layout) OVERRIDE {
+    is_xkb_layout_ = is_xkb_layout;
+  }
+
  private:
   void CallNoResponseMethod(dbus::MethodCall* method_call,
                             const std::string& method_name) {
     proxy_->CallMethodWithErrorCallback(
         method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&IBusInputContextClientImpl::DefaultCallback,
                    method_name),
         base::Bind(&IBusInputContextClientImpl::DefaultErrorCallback,
                    method_name));
@@ skipping 152 matching lines @@
                          bool succeeded) {
     LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " "
                               << signal << " failed.";
   }
 
   dbus::ObjectProxy* proxy_;
 
   // The pointer for input context handler. This can be NULL.
   IBusInputContextHandlerInterface* handler_;
 
+  SetCursorLocationHandler set_cursor_location_handler_;
+
+  // True if the current input method is xkb layout.
+  bool is_xkb_layout_;
+
   base::WeakPtrFactory<IBusInputContextClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IBusInputContextClientImpl);
 };
 
 // An implementation of IBusInputContextClient without ibus-daemon interaction.
 // Currently this class is used only on linux desktop.
 // TODO(nona): Use this on ChromeOS device once crbug.com/171351 is fixed.
 class IBusInputContextClientDaemonlessImpl : public IBusInputContextClient {
  public:
   IBusInputContextClientDaemonlessImpl() {}
   virtual ~IBusInputContextClientDaemonlessImpl() {}
 
   // IBusInputContextClient override.
   virtual void Initialize(dbus::Bus* bus,
                           const dbus::ObjectPath& object_path) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void SetInputContextHandler(
       IBusInputContextHandlerInterface* handler) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
+  virtual void SetSetCursorLocationHandler(
+      const SetCursorLocationHandler& set_cursor_location_handler) OVERRIDE {
+    // TODO(nona): Implement this.
+  }
+
+  virtual void UnsetSetCursorLocationHandler() OVERRIDE {
+    // TODO(nona): Implement this.
+  }
+
   virtual void ResetObjectProxy() OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual bool IsObjectProxyReady() const OVERRIDE {
     // Always true on daemon-less implementation.
     return true;
   }
 
   virtual void SetCapabilities(uint32 capability) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void FocusIn() OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void FocusOut() OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void Reset() OVERRIDE {
     // TODO(nona): Implement this.
   }
 
-  virtual void SetCursorLocation(int32 x, int32 y, int32 w, int32 h) OVERRIDE {
+  virtual void SetCursorLocation(const ibus::Rect& cursor_location,
+                                 const ibus::Rect& composition_head) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void ProcessKeyEvent(
       uint32 keyval,
       uint32 keycode,
       uint32 state,
       const ProcessKeyEventCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE {
     // TODO(nona): Implement this.
     callback.Run(false);
   }
 
   virtual void SetSurroundingText(const std::string& text,
                                   uint32 start_index,
                                   uint32 end_index) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
   virtual void PropertyActivate(const std::string& key,
                                 ibus::IBusPropertyState state) OVERRIDE {
     // TODO(nona): Implement this.
   }
 
+  virtual bool IsXKBLayout() OVERRIDE {
+    // TODO(nona): Implement this.
+    return true;
+  }
+
+  virtual void SetIsXKBLayout(bool is_xkb_layout) OVERRIDE {
+    // TODO(nona): Implement this.
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(IBusInputContextClientDaemonlessImpl);
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // IBusInputContextClient
 
 IBusInputContextClient::IBusInputContextClient() {}
 
 IBusInputContextClient::~IBusInputContextClient() {}
 
 // static
 IBusInputContextClient* IBusInputContextClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION) {
     return new IBusInputContextClientImpl();
   }
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new IBusInputContextClientDaemonlessImpl();
 }
 }  // namespace chromeos