Implements onBoundsChanged event in virtualKeyboardPrivate namespace

chrome/browser/ui/ash/ash_keyboard_controller_proxy.cc

 // Copyright (c) 2013 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/ui/ash/ash_keyboard_controller_proxy.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/shell.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/api/virtual_keyboard_private.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/keyboard/keyboard_controller.h"
+#include "ui/keyboard/keyboard_controller_observer.h"
 
 namespace virtual_keyboard_private =
     extensions::core_api::virtual_keyboard_private;
 
 typedef virtual_keyboard_private::OnTextInputBoxFocused::Context Context;
 
 namespace {
 
 const char* kVirtualKeyboardExtensionID = "mppnpdlheglhdfmldimlhpnegondlapf";
 
@@ skipping 23 matching lines @@
     case ui::TEXT_INPUT_TYPE_WEEK:
     case ui::TEXT_INPUT_TYPE_TEXT_AREA:
     case ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE:
     case ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD:
       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_TEXT;
   }
   NOTREACHED();
   return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_NONE;
 }
 
+class AshKeyboardControllerObserver
+    : public keyboard::KeyboardControllerObserver {
+ public:
+  explicit AshKeyboardControllerObserver(content::BrowserContext* context)
+      : context_(context) {}
+  ~AshKeyboardControllerObserver() override {}
+
+  // KeyboardControllerObserver overrides:
+  void OnKeyboardBoundsChanging(const gfx::Rect& bounds) override {
+    extensions::EventRouter* router = extensions::EventRouter::Get(context_);
+
+    if (!router->HasEventListener(
+            virtual_keyboard_private::OnBoundsChanged::kEventName)) {
+      return;
+    }
+
+    scoped_ptr<base::ListValue> event_args(new base::ListValue());
+    scoped_ptr<base::DictionaryValue> new_bounds(new base::DictionaryValue());
+    new_bounds->SetInteger("left", bounds.x());
+    new_bounds->SetInteger("top", bounds.y());
+    new_bounds->SetInteger("width", bounds.width());
+    new_bounds->SetInteger("height", bounds.height());
+    event_args->Append(new_bounds.release());
+
+    scoped_ptr<extensions::Event> event(new extensions::Event(
+        virtual_keyboard_private::OnBoundsChanged::kEventName,
+        event_args.Pass()));
+    event->restrict_to_browser_context = context_;
+    router->BroadcastEvent(event.Pass());
+  }
+
+ private:
+  content::BrowserContext* context_;
+
+  DISALLOW_COPY_AND_ASSIGN(AshKeyboardControllerObserver);
+};
+
 }  // namespace
 
 AshKeyboardControllerProxy::AshKeyboardControllerProxy(
     content::BrowserContext* context)
     : keyboard::KeyboardControllerProxy(context) {
 }
 
-AshKeyboardControllerProxy::~AshKeyboardControllerProxy() {}
+AshKeyboardControllerProxy::~AshKeyboardControllerProxy() {
+  DCHECK(!keyboard_controller_);
+}
 
 void AshKeyboardControllerProxy::OnRequest(
     const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_->Dispatch(
       params, web_contents()->GetRenderViewHost());
 }
 
 ui::InputMethod* AshKeyboardControllerProxy::GetInputMethod() {
   aura::Window* root_window = ash::Shell::GetInstance()->GetPrimaryRootWindow();
   DCHECK(root_window);
@@ skipping 26 matching lines @@
       contents);
   Observe(contents);
 }
 
 extensions::WindowController*
     AshKeyboardControllerProxy::GetExtensionWindowController() const {
   // The keyboard doesn't have a window controller.
   return NULL;
 }
 
+void AshKeyboardControllerProxy::SetController(
+    keyboard::KeyboardController* controller) {
+  // During KeyboardController destruction, controller can be set to null.
+  if (!controller) {
+    DCHECK(keyboard_controller_);
+    keyboard_controller_->RemoveObserver(observer_.get());
+    keyboard_controller_ = nullptr;
+    return;
+  }
+  keyboard_controller_ = controller;
+  observer_.reset(new AshKeyboardControllerObserver(browser_context()));
+  keyboard_controller_->AddObserver(observer_.get());
+}
+
 content::WebContents*
     AshKeyboardControllerProxy::GetAssociatedWebContents() const {
   return web_contents();
 }
 
 bool AshKeyboardControllerProxy::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AshKeyboardControllerProxy, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
@@ skipping 39 matching lines @@
                            virtual_keyboard_private::ToString(
                                TextInputTypeToGeneratedInputTypeEnum(type)));
   event_args->Append(input_context.release());
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       virtual_keyboard_private::OnTextInputBoxFocused::kEventName,
       event_args.Pass()));
   event->restrict_to_browser_context = browser_context();
   router->DispatchEventToExtension(kVirtualKeyboardExtensionID, event.Pass());
 }