chrome/browser/ui/ash/ash_keyboard_controller_proxy.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/ash/ash_keyboard_controller_proxy.h"
   6
   7 #include "ash/display/display_controller.h"
   8 #include "ash/shell.h"
   9 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
  10 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
  11 #include "content/public/browser/host_zoom_map.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/public/browser/render_view_host.h"
  14 #include "content/public/browser/site_instance.h"
  15 #include "content/public/browser/web_contents.h"
  16 #include "extensions/browser/event_router.h"
  17 #include "extensions/browser/extension_registry.h"
  18 #include "extensions/browser/view_type_utils.h"
  19 #include "extensions/common/api/virtual_keyboard_private.h"
  20 #include "extensions/common/constants.h"
  21 #include "extensions/common/extension_messages.h"
  22 #include "ipc/ipc_message_macros.h"
  23 #include "ui/aura/window.h"
  24 #include "ui/aura/window_event_dispatcher.h"
  25 #include "ui/aura/window_tree_host.h"
  26 #include "ui/compositor/scoped_layer_animation_settings.h"
  27 #include "ui/keyboard/keyboard_controller.h"
  28 #include "ui/keyboard/keyboard_controller_observer.h"
  29
  30 namespace virtual_keyboard_private =
  31     extensions::core_api::virtual_keyboard_private;
  32
  33 typedef virtual_keyboard_private::OnTextInputBoxFocused::Context Context;
  34
  35 namespace {
  36
  37 const char* kVirtualKeyboardExtensionID = "mppnpdlheglhdfmldimlhpnegondlapf";
  38
  39 virtual_keyboard_private::OnTextInputBoxFocusedType
  40 TextInputTypeToGeneratedInputTypeEnum(ui::TextInputType type) {
  41   switch (type) {
  42     case ui::TEXT_INPUT_TYPE_NONE:
  43       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_NONE;
  44     case ui::TEXT_INPUT_TYPE_PASSWORD:
  45       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_PASSWORD;
  46     case ui::TEXT_INPUT_TYPE_EMAIL:
  47       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_EMAIL;
  48     case ui::TEXT_INPUT_TYPE_NUMBER:
  49       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_NUMBER;
  50     case ui::TEXT_INPUT_TYPE_TELEPHONE:
  51       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_TEL;
  52     case ui::TEXT_INPUT_TYPE_URL:
  53       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_URL;
  54     case ui::TEXT_INPUT_TYPE_DATE:
  55       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_DATE;
  56     case ui::TEXT_INPUT_TYPE_TEXT:
  57     case ui::TEXT_INPUT_TYPE_SEARCH:
  58     case ui::TEXT_INPUT_TYPE_DATE_TIME:
  59     case ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL:
  60     case ui::TEXT_INPUT_TYPE_MONTH:
  61     case ui::TEXT_INPUT_TYPE_TIME:
  62     case ui::TEXT_INPUT_TYPE_WEEK:
  63     case ui::TEXT_INPUT_TYPE_TEXT_AREA:
  64     case ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE:
  65     case ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD:
  66       return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_TEXT;
  67   }
  68   NOTREACHED();
  69   return virtual_keyboard_private::ON_TEXT_INPUT_BOX_FOCUSED_TYPE_NONE;
  70 }
  71
  72 class AshKeyboardControllerObserver
  73     : public keyboard::KeyboardControllerObserver {
  74  public:
  75   explicit AshKeyboardControllerObserver(content::BrowserContext* context)
  76       : context_(context) {}
  77   ~AshKeyboardControllerObserver() override {}
  78
  79   // KeyboardControllerObserver overrides:
  80   void OnKeyboardBoundsChanging(const gfx::Rect& bounds) override {
  81     extensions::EventRouter* router = extensions::EventRouter::Get(context_);
  82
  83     if (!router->HasEventListener(
  84             virtual_keyboard_private::OnBoundsChanged::kEventName)) {
  85       return;
  86     }
  87
  88     scoped_ptr<base::ListValue> event_args(new base::ListValue());
  89     scoped_ptr<base::DictionaryValue> new_bounds(new base::DictionaryValue());
  90     new_bounds->SetInteger("left", bounds.x());
  91     new_bounds->SetInteger("top", bounds.y());
  92     new_bounds->SetInteger("width", bounds.width());
  93     new_bounds->SetInteger("height", bounds.height());
  94     event_args->Append(new_bounds.release());
  95
  96     scoped_ptr<extensions::Event> event(new extensions::Event(
  97         extensions::events::VIRTUAL_KEYBOARD_PRIVATE_ON_BOUNDS_CHANGED,
  98         virtual_keyboard_private::OnBoundsChanged::kEventName,
  99         event_args.Pass()));
 100     event->restrict_to_browser_context = context_;
 101     router->BroadcastEvent(event.Pass());
 102   }
 103
 104  private:
 105   content::BrowserContext* context_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(AshKeyboardControllerObserver);
 108 };
 109
 110 }  // namespace
 111
 112 AshKeyboardControllerProxy::AshKeyboardControllerProxy(
 113     content::BrowserContext* context)
 114     : keyboard::KeyboardControllerProxy(context) {
 115 }
 116
 117 AshKeyboardControllerProxy::~AshKeyboardControllerProxy() {
 118   DCHECK(!keyboard_controller());
 119 }
 120
 121 ui::InputMethod* AshKeyboardControllerProxy::GetInputMethod() {
 122   aura::Window* root_window = ash::Shell::GetTargetRootWindow();
 123   DCHECK(root_window);
 124   return root_window->GetHost()->GetInputMethod();
 125 }
 126
 127 void AshKeyboardControllerProxy::RequestAudioInput(
 128       content::WebContents* web_contents,
 129       const content::MediaStreamRequest& request,
 130       const content::MediaResponseCallback& callback) {
 131   const extensions::Extension* extension = NULL;
 132   GURL origin(request.security_origin);
 133   if (origin.SchemeIs(extensions::kExtensionScheme)) {
 134     const extensions::ExtensionRegistry* registry =
 135         extensions::ExtensionRegistry::Get(browser_context());
 136     extension = registry->enabled_extensions().GetByID(origin.host());
 137     DCHECK(extension);
 138   }
 139
 140   MediaCaptureDevicesDispatcher::GetInstance()->ProcessMediaAccessRequest(
 141       web_contents, request, callback, extension);
 142 }
 143
 144 void AshKeyboardControllerProxy::SetupWebContents(
 145     content::WebContents* contents) {
 146   extensions::SetViewType(contents, extensions::VIEW_TYPE_VIRTUAL_KEYBOARD);
 147   extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
 148       contents);
 149   Observe(contents);
 150 }
 151
 152 void AshKeyboardControllerProxy::SetController(
 153     keyboard::KeyboardController* controller) {
 154   // During KeyboardController destruction, controller can be set to null.
 155   if (!controller) {
 156     DCHECK(keyboard_controller());
 157     keyboard_controller()->RemoveObserver(observer_.get());
 158     KeyboardControllerProxy::SetController(nullptr);
 159     return;
 160   }
 161   KeyboardControllerProxy::SetController(controller);
 162   observer_.reset(new AshKeyboardControllerObserver(browser_context()));
 163   keyboard_controller()->AddObserver(observer_.get());
 164 }
 165
 166 void AshKeyboardControllerProxy::RenderViewCreated(
 167     content::RenderViewHost* render_view_host) {
 168   content::HostZoomMap* zoom_map =
 169       content::HostZoomMap::GetDefaultForBrowserContext(browser_context());
 170   DCHECK(zoom_map);
 171   int render_process_id = render_view_host->GetProcess()->GetID();
 172   int render_view_id = render_view_host->GetRoutingID();
 173   zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id, 0);
 174 }
 175
 176 void AshKeyboardControllerProxy::ShowKeyboardContainer(
 177     aura::Window* container) {
 178   // TODO(bshe): Implement logic to decide which root window should display
 179   // virtual keyboard. http://crbug.com/303429
 180   if (container->GetRootWindow() != ash::Shell::GetPrimaryRootWindow())
 181     NOTIMPLEMENTED();
 182
 183   KeyboardControllerProxy::ShowKeyboardContainer(container);
 184 }
 185
 186 void AshKeyboardControllerProxy::SetUpdateInputType(ui::TextInputType type) {
 187   // TODO(bshe): Need to check the affected window's profile once multi-profile
 188   // is supported.
 189   extensions::EventRouter* router =
 190       extensions::EventRouter::Get(browser_context());
 191
 192   if (!router->HasEventListener(
 193           virtual_keyboard_private::OnTextInputBoxFocused::kEventName)) {
 194     return;
 195   }
 196
 197   scoped_ptr<base::ListValue> event_args(new base::ListValue());
 198   scoped_ptr<base::DictionaryValue> input_context(new base::DictionaryValue());
 199   input_context->SetString("type",
 200                            virtual_keyboard_private::ToString(
 201                                TextInputTypeToGeneratedInputTypeEnum(type)));
 202   event_args->Append(input_context.release());
 203
 204   scoped_ptr<extensions::Event> event(new extensions::Event(
 205       extensions::events::VIRTUAL_KEYBOARD_PRIVATE_ON_TEXT_INPUT_BOX_FOCUSED,
 206       virtual_keyboard_private::OnTextInputBoxFocused::kEventName,
 207       event_args.Pass()));
 208   event->restrict_to_browser_context = browser_context();
 209   router->DispatchEventToExtension(kVirtualKeyboardExtensionID, event.Pass());
 210 }