athena: Add support for virtual keyboard.

athena/virtual_keyboard/virtual_keyboard_manager_impl.cc

Index: athena/virtual_keyboard/virtual_keyboard_manager_impl.cc
diff --git a/athena/virtual_keyboard/virtual_keyboard_manager_impl.cc b/athena/virtual_keyboard/virtual_keyboard_manager_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6a77a47700c6180298973635a0936ff197e4ccd5
--- /dev/null
+++ b/athena/virtual_keyboard/virtual_keyboard_manager_impl.cc
@@ -0,0 +1,159 @@
+// Copyright 2014 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 "athena/virtual_keyboard/public/virtual_keyboard_manager.h"
+
+#include "athena/screen/public/screen_manager.h"
+#include "athena/virtual_keyboard/vk_webui_controller.h"
+#include "base/bind.h"
+#include "base/memory/singleton.h"
+#include "base/values.h"
+#include "content/public/browser/browser_context.h"
+#include "ui/aura/client/aura_constants.h"
+#include "ui/aura/layout_manager.h"
+#include "ui/aura/window.h"
+#include "ui/keyboard/keyboard.h"
+#include "ui/keyboard/keyboard_constants.h"
+#include "ui/keyboard/keyboard_controller.h"
+#include "ui/keyboard/keyboard_controller_proxy.h"
+#include "ui/keyboard/keyboard_util.h"
+
+namespace athena {
+
+namespace {
+
+VirtualKeyboardManager* instance;
+
+class FillLayoutManager : public aura::LayoutManager {

[oshima, 2014/06/18 20:14:35]

can you move the FillLaout from screen/screen_manager_impl.cc to common/ and use
it?

[sadrul, 2014/06/18 20:57:53]

Done.

+ public:
+  explicit FillLayoutManager(aura::Window* container) : container_(container) {
+    DCHECK(container_);
+  }
+
+  // aura::LayoutManager:
+  virtual void OnWindowResized() OVERRIDE {
+    gfx::Rect full_bounds = gfx::Rect(container_->bounds().size());
+    for (aura::Window::Windows::const_iterator iter =
+             container_->children().begin();
+         iter != container_->children().end();
+         ++iter) {
+      SetChildBoundsDirect(*iter, full_bounds);
+    }
+  }
+  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
+    SetChildBoundsDirect(child, (gfx::Rect(container_->bounds().size())));
+  }
+  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
+  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {}
+  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
+                                              bool visible) OVERRIDE {}
+  virtual void SetChildBounds(aura::Window* child,
+                              const gfx::Rect& requested_bounds) OVERRIDE {
+    // Ignore SetBounds request.
+  }
+
+ private:
+  aura::Window* container_;
+
+  DISALLOW_COPY_AND_ASSIGN(FillLayoutManager);
+};
+
+// A very basic and simple implementation of KeyboardControllerProxy.
+class BasicKeyboardControllerProxy : public keyboard::KeyboardControllerProxy {
+ public:
+  BasicKeyboardControllerProxy(content::BrowserContext* context,
+                               aura::Window* root_window)
+      : browser_context_(context), root_window_(root_window) {}
+  virtual ~BasicKeyboardControllerProxy() {}
+
+  // keyboard::KeyboardControllerProxy:
+  virtual ui::InputMethod* GetInputMethod() OVERRIDE {
+    ui::InputMethod* input_method =
+        root_window_->GetProperty(aura::client::kRootWindowInputMethodKey);
+    return input_method;
+  }
+
+  virtual void RequestAudioInput(
+      content::WebContents* web_contents,
+      const content::MediaStreamRequest& request,
+      const content::MediaResponseCallback& callback) OVERRIDE {}
+
+  virtual content::BrowserContext* GetBrowserContext() OVERRIDE {
+    return browser_context_;
+  }
+
+ private:
+  content::BrowserContext* browser_context_;
+  aura::Window* root_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(BasicKeyboardControllerProxy);
+};
+
+class VirtualKeyboardManagerImpl : public VirtualKeyboardManager {
+ public:
+  VirtualKeyboardManagerImpl(aura::Window* window,
+                             content::BrowserContext* browser_context)
+      : browser_context_(browser_context),
+        root_window_(window),
+        container_(NULL) {
+    CHECK(!instance);
+    instance = this;
+    Init();
+  }
+
+  virtual ~VirtualKeyboardManagerImpl() {
+    CHECK_EQ(this, instance);
+    instance = NULL;

[oshima, 2014/06/18 20:14:35]

don't you have to do any cleanup where?

[sadrul, 2014/06/18 20:57:52]

What kind of cleanup do you think could be useful here? The keyboard-controller
is destroyed from the destructor because it's a scoped_ptr<>. The
WebUIControllerFactory installed using ::RegisterFactory() cannot be
unregistered (there's only a ::UnregisterFactoryForTesting()).

[oshima, 2014/06/18 21:11:15]

Don't you have to do

keyboard::KeyboardController::ResetInstance(NULL)

? I'm not familiar with VK code, so I may be wrong, but ash/shell seems to be
doing this in dtor.

[sadrul, 2014/06/18 21:19:10]

Yes, good catch! Done. Thanks

+  }
+
+ private:
+  void Init() {
+    container_ = athena::ScreenManager::Get()->CreateContainer(
+        "VirtualKeyboardContainer");
+    container_->SetLayoutManager(new FillLayoutManager(container_));
+    keyboard::SetOverrideContentUrl(GURL(keyboard::kKeyboardURL));
+
+    keyboard_controller_.reset(new keyboard::KeyboardController(
+        new BasicKeyboardControllerProxy(browser_context_, root_window_)));

[oshima, 2014/06/18 20:14:35]

can you simply use container_->GetRootWindow() instead?

[sadrul, 2014/06/18 20:57:52]

Done.

+    keyboard::KeyboardController::ResetInstance(keyboard_controller_.get());
+    aura::Window* kb_container = keyboard_controller_->GetContainerWindow();
+    container_->AddChild(kb_container);
+    kb_container->Show();
+
+    content::WebUIControllerFactory::RegisterFactory(
+        VKWebUIControllerFactory::GetInstance());
+  }
+
+  content::BrowserContext* browser_context_;
+  aura::Window* root_window_;
+  aura::Window* container_;
+  scoped_ptr<keyboard::KeyboardController> keyboard_controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardManagerImpl);
+};
+
+}  // namespace
+
+// static
+VirtualKeyboardManager* VirtualKeyboardManager::Create(
+    aura::Window* root,
+    content::BrowserContext* browser_context) {
+  CHECK(!instance);
+  keyboard::InitializeKeyboard();
+  new VirtualKeyboardManagerImpl(root, browser_context);
+  CHECK(instance);
+  return instance;
+}
+
+VirtualKeyboardManager* VirtualKeyboardManager::Get() {
+  return instance;
+}
+
+void VirtualKeyboardManager::Shutdown() {
+  CHECK(instance);
+  delete instance;
+  CHECK(!instance);
+}
+
+}  // namespace athena