android: Introduce a ui::PlatformWindow implementation for android.

components/view_manager/native_viewport/platform_viewport_common.cc

 // Copyright 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 "components/view_manager/native_viewport/platform_viewport.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "components/view_manager/native_viewport/platform_viewport_headless.h"
 #include "components/view_manager/public/interfaces/view_manager.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/platform_window_delegate.h"
+
+#if defined(OS_WIN)
+#include "ui/platform_window/win/win_window.h"
+#elif defined(USE_X11)
 #include "ui/platform_window/x11/x11_window.h"
+#elif defined(OS_ANDROID)
+#include "ui/platform_window/android/platform_window_android.h"
+#endif
 
 namespace native_viewport {
 namespace {
 
 float ConvertUIWheelValueToMojoValue(int offset) {
   // Mojo's event type takes a value between -1 and 1. Normalize by allowing
   // up to 20 of ui's offset. This is a bit arbitrary.
   return std::max(
       -1.0f, std::min(1.0f, static_cast<float>(offset) /
                                 (20 * static_cast<float>(
                                           ui::MouseWheelEvent::kWheelDelta))));
 }
 }  // namespace
 
-class PlatformViewportX11 : public PlatformViewport,
-                            public ui::PlatformWindowDelegate {
+class PlatformViewportCommon : public PlatformViewport,
+                               public ui::PlatformWindowDelegate {
  public:
-  explicit PlatformViewportX11(Delegate* delegate) : delegate_(delegate) {
+  explicit PlatformViewportCommon(Delegate* delegate) : delegate_(delegate) {
   }
 
-  ~PlatformViewportX11() override {
+  ~PlatformViewportCommon() override {
     // Destroy the platform-window while |this| is still alive.
     platform_window_.reset();
   }
 
  private:
   // Overridden from PlatformViewport:
   void Init(const gfx::Rect& bounds) override {
     CHECK(!platform_window_);
 
     metrics_ = mojo::ViewportMetrics::New();
     // TODO(sky): make density real.
     metrics_->device_pixel_ratio = 1.f;
     metrics_->size_in_pixels = mojo::Size::From(bounds.size());
 
+#if defined(OS_WIN)
+    platform_window_.reset(new ui::WinWindow(this, bounds));
+#elif defined(USE_X11)
     platform_window_.reset(new ui::X11Window(this));
+#elif defined(OS_ANDROID)
+    platform_window_.reset(new ui::PlatformWindowAndroid(this));
+#endif
     platform_window_->SetBounds(bounds);
   }
 
   void Show() override { platform_window_->Show(); }
 
   void Hide() override { platform_window_->Hide(); }
 
   void Close() override { platform_window_->Close(); }
 
   gfx::Size GetSize() override {
@@ skipping 34 matching lines @@
         platform_window_->SetCapture();
         break;
       case ui::ET_MOUSE_RELEASED:
       case ui::ET_TOUCH_RELEASED:
         platform_window_->ReleaseCapture();
         break;
       default:
         break;
     }
 
+#if defined(USE_X11)
     // We want to emulate the WM_CHAR generation behaviour of Windows.
     //
     // On Linux, we've previously inserted characters by having
     // InputMethodAuraLinux take all key down events and send a character event
     // to the TextInputClient. This causes a mismatch in code that has to be
     // shared between Windows and Linux, including blink code. Now that we're
     // trying to have one way of doing things, we need to standardize on and
     // emulate Windows character events.
     //
     // This is equivalent to what we're doing in the current Linux port, but
@@ skipping 10 matching lines @@
 
       char_event.SetExtendedKeyEventData(
           make_scoped_ptr(new mojo::MojoExtendedKeyEventData(
               key_press_event->GetLocatedWindowsKeyboardCode(),
               key_press_event->GetText(),
               key_press_event->GetUnmodifiedText())));
       char_event.set_platform_keycode(key_press_event->platform_keycode());
 
       delegate_->OnEvent(mojo::Event::From(char_event));
     }
+#endif
   }
 
   void OnCloseRequest() override { platform_window_->Close(); }
 
   void OnClosed() override { delegate_->OnDestroyed(); }
 
   void OnWindowStateChanged(ui::PlatformWindowState state) override {}
 
   void OnLostCapture() override {}
 
   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) override {
     delegate_->OnAcceleratedWidgetAvailable(widget,
                                             metrics_->device_pixel_ratio);
   }
 
   void OnActivationChanged(bool active) override {}
 
   scoped_ptr<ui::PlatformWindow> platform_window_;
   Delegate* delegate_;
   mojo::ViewportMetricsPtr metrics_;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformViewportX11);
+  DISALLOW_COPY_AND_ASSIGN(PlatformViewportCommon);
 };
 
 // static
 scoped_ptr<PlatformViewport> PlatformViewport::Create(Delegate* delegate,
                                                       bool headless) {
   if (headless)
     return PlatformViewportHeadless::Create(delegate);
-  return make_scoped_ptr(new PlatformViewportX11(delegate));
+  return make_scoped_ptr(new PlatformViewportCommon(delegate));
 }
 
 }  // namespace native_viewport