VR: Add keyboard support from the test app

Bug: 
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I27c2689ebf8b4c5027cb272cf8359f68a6e2918a
Reviewed-on: https://chromium-review.googlesource.com/822234
Commit-Queue: Yash Malik <ymalik@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524193}

chrome/browser/vr/testapp/BUILD.gn

@@ -8,6 +8,10 @@ executable("vr_testapp") {
   sources = [
     "gl_renderer.cc",
     "gl_renderer.h",
+    "test_keyboard_delegate.cc",
+    "test_keyboard_delegate.h",
+    "test_keyboard_renderer.cc",
+    "test_keyboard_renderer.h",
     "vr_test_context.cc",
     "vr_test_context.h",
     "vr_testapp.cc",

chrome/browser/vr/testapp/test_keyboard_delegate.cc

+// Copyright 2017 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/vr/testapp/test_keyboard_delegate.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/strings/utf_string_conversion_utils.h"
+#include "base/strings/utf_string_conversions.h"
+#include "ui/events/event.h"
+#include "ui/events/keycodes/dom/dom_code.h"
+
+namespace vr {
+
+namespace {
+
+constexpr gfx::SizeF kKeyboardSize = {1.2f, 0.37f};
+constexpr gfx::Vector2dF kKeyboardTranslate = {0, -0.1};
+
+}  // namespace
+
+TestKeyboardDelegate::TestKeyboardDelegate()
+    : renderer_(base::MakeUnique<TestKeyboardRenderer>()) {}
+
+TestKeyboardDelegate::~TestKeyboardDelegate() {}
+
+void TestKeyboardDelegate::ShowKeyboard() {
+  editing_ = true;
+}
+
+void TestKeyboardDelegate::HideKeyboard() {
+  editing_ = false;
+}
+
+void TestKeyboardDelegate::SetTransform(const gfx::Transform& transform) {
+  world_space_transform_ = transform;
+}
+
+bool TestKeyboardDelegate::HitTest(const gfx::Point3F& ray_origin,
+                                   const gfx::Point3F& ray_target,
+                                   gfx::Point3F* hit_position) {
+  // TODO(ymalik): Add hittesting logic for the keyboard.
+  return false;
+}
+
+void TestKeyboardDelegate::Draw(const CameraModel& model) {
+  if (!editing_)
+    return;
+
+  // We try to simulate what the gvr keyboard does here by scaling and
+  // translating the keyboard on top of the provided transform.
+  gfx::Transform world_space_transform = world_space_transform_;
+  world_space_transform.Scale(kKeyboardSize.width(), kKeyboardSize.height());
+  world_space_transform.Translate(kKeyboardTranslate);
+  renderer_->Draw(model, world_space_transform);
+}
+
+void TestKeyboardDelegate::Initialize(vr::SkiaSurfaceProvider* provider,
+                                      UiElementRenderer* renderer) {
+  renderer_->Initialize(provider, renderer);
+}
+
+bool TestKeyboardDelegate::HandleInput(ui::Event* e) {
+  DCHECK(keyboard_interface_);
+  DCHECK(e->IsKeyEvent());
+  if (!editing_)
+    return false;
+
+  auto* event = e->AsKeyEvent();
+  switch (event->key_code()) {
+    case ui::VKEY_RETURN:
+      input_info_.text.clear();
+      input_info_.selection_start = input_info_.selection_end = 0;
+      keyboard_interface_->OnInputCommitted(input_info_);
+      break;
+    case ui::VKEY_BACK:
+      input_info_.text.pop_back();
+      input_info_.selection_start--;
+      input_info_.selection_end--;
+      keyboard_interface_->OnInputEdited(input_info_);
+      break;
+    default:
+      std::string character;
+      base::WriteUnicodeCharacter(event->GetText(), &character);
+      input_info_.text = input_info_.text.append(base::UTF8ToUTF16(character));
+      input_info_.selection_start++;
+      input_info_.selection_end++;
+      keyboard_interface_->OnInputEdited(input_info_);
+      break;
+  }
+  // We want to continue handling this keypress if the Ctrl key is down so
+  // that we can do things like duming the tree in editing mode.
+  return !event->IsControlDown();
+}
+
+}  // namespace vr

chrome/browser/vr/testapp/test_keyboard_delegate.h

+// Copyright 2017 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.
+
+#ifndef CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_DELEGATE_H_
+#define CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_DELEGATE_H_
+
+#include "base/macros.h"
+#include "chrome/browser/vr/keyboard_delegate.h"
+#include "chrome/browser/vr/keyboard_ui_interface.h"
+#include "chrome/browser/vr/model/text_input_info.h"
+#include "chrome/browser/vr/testapp/test_keyboard_renderer.h"
+#include "ui/gfx/transform.h"
+
+namespace gfx {
+class Point3F;
+}  // namespace gfx
+
+namespace ui {
+class Event;
+}  // namespace ui
+
+namespace vr {
+
+class UiElementRenderer;
+struct CameraModel;
+
+class TestKeyboardDelegate : public KeyboardDelegate {
+ public:
+  TestKeyboardDelegate();
+  ~TestKeyboardDelegate() override;
+
+  void ShowKeyboard() override;
+  void HideKeyboard() override;
+  void SetTransform(const gfx::Transform& transform) override;
+  bool HitTest(const gfx::Point3F& ray_origin,
+               const gfx::Point3F& ray_target,
+               gfx::Point3F* hit_position) override;
+  void Draw(const CameraModel& model) override;
+
+  void Initialize(SkiaSurfaceProvider* provider, UiElementRenderer* renderer);
+  void SetUiInterface(KeyboardUiInterface* keyboard) {
+    keyboard_interface_ = keyboard;
+  }
+  void UpdateInput(const vr::TextInputInfo& info) { input_info_ = info; }
+  bool HandleInput(ui::Event* e);
+
+ private:
+  std::unique_ptr<TestKeyboardRenderer> renderer_;
+  KeyboardUiInterface* keyboard_interface_ = nullptr;
+  gfx::Transform world_space_transform_;
+  bool editing_;
+  TextInputInfo input_info_;
+};
+
+}  // namespace vr
+
+#endif  // CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_DELEGATE_H_

chrome/browser/vr/testapp/test_keyboard_renderer.cc

+// Copyright 2017 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/vr/testapp/test_keyboard_renderer.h"
+
+#include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
+#include "base/path_service.h"
+#include "base/strings/utf_string_conversion_utils.h"
+#include "chrome/browser/vr/skia_surface_provider.h"
+#include "chrome/browser/vr/ui_element_renderer.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "ui/gfx/codec/png_codec.h"
+
+namespace vr {
+
+namespace {
+constexpr char kKeyboardImagePath[] = "chrome/browser/vr/testapp/keyboard.png";
+}  // namespace
+
+TestKeyboardRenderer::TestKeyboardRenderer() = default;
+TestKeyboardRenderer::~TestKeyboardRenderer() = default;
+
+void TestKeyboardRenderer::Initialize(SkiaSurfaceProvider* provider,
+                                      UiElementRenderer* renderer) {
+  renderer_ = renderer;
+
+  // Note that we simply render an image for the keyboard and the actual input
+  // is provided by the physical keyboard.
+  // Read and decode keyboard image.
+  base::FilePath dir;
+  PathService::Get(base::DIR_CURRENT, &dir);
+  dir = dir.Append(base::FilePath().AppendASCII(kKeyboardImagePath));
+  DCHECK(base::PathExists(dir));
+  std::string file_contents;
+  base::ReadFileToString(dir, &file_contents);
+  const unsigned char* data =
+      reinterpret_cast<const unsigned char*>(file_contents.data());
+  SkBitmap bitmap;
+  gfx::PNGCodec::Decode(data, file_contents.length(), &bitmap);
+
+  drawn_size_.SetSize(bitmap.width(), bitmap.height());
+  surface_ = provider->MakeSurface(drawn_size_);
+  DCHECK(surface_);
+
+  surface_->getCanvas()->drawBitmap(bitmap, 0, 0);
+  texture_handle_ = provider->FlushSurface(surface_.get(), texture_handle_);
+}
+
+void TestKeyboardRenderer::Draw(const CameraModel& model,
+                                const gfx::Transform& world_space_transform) {
+  renderer_->DrawTexturedQuad(
+      texture_handle_, UiElementRenderer::kTextureLocationLocal,
+      model.view_proj_matrix * world_space_transform, gfx::RectF(0, 0, 1, 1), 1,
+      {drawn_size_.width(), drawn_size_.height()}, 0);
+}
+
+}  // namespace vr

chrome/browser/vr/testapp/test_keyboard_renderer.h

+// Copyright 2017 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.
+
+#ifndef CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_RENDERER_H_
+#define CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_RENDERER_H_
+
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace gfx {
+class Transform;
+}  // namespace gfx
+
+namespace vr {
+
+class SkiaSurfaceProvider;
+class UiElementRenderer;
+struct CameraModel;
+
+class TestKeyboardRenderer {
+ public:
+  TestKeyboardRenderer();
+  ~TestKeyboardRenderer();
+
+  void Initialize(SkiaSurfaceProvider* provider, UiElementRenderer* renderer);
+  void Draw(const CameraModel& model,
+            const gfx::Transform& world_space_transform);
+
+ private:
+  GLuint texture_handle_;
+  sk_sp<SkSurface> surface_;
+  gfx::Size drawn_size_;
+  UiElementRenderer* renderer_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(TestKeyboardRenderer);
+};
+
+}  // namespace vr
+
+#endif  // CHROME_BROWSER_VR_TESTAPP_TEST_KEYBOARD_RENDERER_H_

chrome/browser/vr/testapp/vr_test_context.cc

@@ -11,12 +11,12 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/vr/controller_mesh.h"
-#include "chrome/browser/vr/keyboard_delegate.h"
 #include "chrome/browser/vr/model/model.h"
 #include "chrome/browser/vr/model/omnibox_suggestions.h"
 #include "chrome/browser/vr/model/toolbar_state.h"
 #include "chrome/browser/vr/speech_recognizer.h"
 #include "chrome/browser/vr/test/constants.h"
+#include "chrome/browser/vr/testapp/test_keyboard_delegate.h"
 #include "chrome/browser/vr/text_input_delegate.h"
 #include "chrome/browser/vr/ui.h"
 #include "chrome/browser/vr/ui_element_renderer.h"
@@ -32,6 +32,7 @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom/dom_code.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/angle_conversions.h"
 
@@ -58,31 +59,6 @@ void RotateToward(const gfx::Vector3dF& fwd, gfx::Transform* transform) {
 
 }  // namespace
 
-// This stub delegate does nothing today, but can be expanded to offer
-// legitimate keyboard support if required.
-class TestKeyboardDelegate : KeyboardDelegate {
- public:
-  // KeyboardDelegate implemenation.
-  void ShowKeyboard() override {}
-  void HideKeyboard() override {}
-  void SetTransform(const gfx::Transform&) override {}
-  bool HitTest(const gfx::Point3F& ray_origin,
-               const gfx::Point3F& ray_target,
-               gfx::Point3F* hit_position) override {
-    return false;
-  }
-  void Draw(const CameraModel&) override {}
-
-  // Testapp-specific hooks.
-  void SetUiInterface(vr::KeyboardUiInterface* keyboard) {
-    keyboard_interface_ = keyboard;
-  }
-  void UpdateInput(const vr::TextInputInfo& info) {}
-
- private:
-  vr::KeyboardUiInterface* keyboard_interface_ = nullptr;
-};
-
 VrTestContext::VrTestContext() : view_scale_factor_(kDefaultViewScaleFactor) {
   base::FilePath pak_path;
   PathService::Get(base::DIR_MODULE, &pak_path);
@@ -94,11 +70,11 @@ VrTestContext::VrTestContext() : view_scale_factor_(kDefaultViewScaleFactor) {
   // TODO(cjgrant): Remove this when the keyboard is enabled by default.
   base::FeatureList::InitializeInstance("VrBrowserKeyboard", "");
 
-  text_input_delegate_ = base::MakeUnique<vr::TextInputDelegate>();
-  keyboard_delegate_ = base::MakeUnique<vr::TestKeyboardDelegate>();
+  text_input_delegate_ = base::MakeUnique<TextInputDelegate>();
+  keyboard_delegate_ = base::MakeUnique<TestKeyboardDelegate>();
 
-  ui_ = base::MakeUnique<Ui>(this, nullptr, nullptr, text_input_delegate_.get(),
-                             UiInitialState());
+  ui_ = base::MakeUnique<Ui>(this, nullptr, keyboard_delegate_.get(),
+                             text_input_delegate_.get(), UiInitialState());
 
   text_input_delegate_->SetRequestFocusCallback(
       base::BindRepeating(&vr::Ui::RequestFocus, base::Unretained(ui_.get())));
@@ -158,6 +134,9 @@ void VrTestContext::HandleInput(ui::Event* event) {
     if (event->type() != ui::ET_KEY_PRESSED) {
       return;
     }
+    if (keyboard_delegate_->HandleInput(event)) {
+      return;
+    }
     switch (event->AsKeyEvent()->code()) {
       case ui::DomCode::ESCAPE:
         view_scale_factor_ = kDefaultViewScaleFactor;
@@ -332,6 +311,9 @@ void VrTestContext::OnGlInitialized() {
   ui_->OnGlInitialized(content_texture_id,
                        UiElementRenderer::kTextureLocationLocal, false);
 
+  keyboard_delegate_->Initialize(ui_->scene()->SurfaceProviderForTesting(),
+                                 ui_->ui_element_renderer());
+
   ui_->ui_element_renderer()->SetUpController(
       ControllerMesh::LoadFromResources());
 }
@@ -458,7 +440,6 @@ void VrTestContext::OnUnsupportedMode(vr::UiUnsupportedMode mode) {
 
 void VrTestContext::OnExitVrPromptResult(vr::ExitVrPromptChoice choice,
                                          vr::UiUnsupportedMode reason) {
-  LOG(ERROR) << "exit prompt result: " << choice;
   if (reason == UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission &&
       choice == CHOICE_EXIT) {
     voice_search_enabled_ = true;

chrome/browser/vr/ui_scene.h

@@ -75,6 +75,8 @@ class UiScene {
 
   void OnGlInitialized(SkiaSurfaceProvider* provider);
 
+  SkiaSurfaceProvider* SurfaceProviderForTesting() { return provider_; }
+
  private:
   void InitializeElement(UiElement* element);