blimp: Add support for input handling

blimp/client/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 53 matching lines @@
 }
 
 BlimpCompositor::~BlimpCompositor() {
   render_widget_processor_.RemoveDelegate(kDummyTabId);
   SetVisible(false);
 
   // Destroy |host_| first, as it has a reference to the |settings_| and runs
   // tasks on |compositor_thread_|.
   host_.reset();
   settings_.reset();
+
+  // We must destroy |host_| before the |input_manager_|.
+  input_manager_.reset();
+
   if (compositor_thread_)
     compositor_thread_->Stop();
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   // For testing.  Remove once we bind to the network layer.
   if (!host_)
     CreateLayerTreeHost(nullptr);
 
   host_should_be_visible_ = visible;
@@ skipping 40 matching lines @@
 void BlimpCompositor::ReleaseAcceleratedWidget() {
   if (window_ == gfx::kNullAcceleratedWidget)
     return;
 
   // Hide the compositor and drop the output surface if necessary.
   SetVisible(false);
 
   window_ = gfx::kNullAcceleratedWidget;
 }
 
+bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
+  if (input_manager_)
+    return input_manager_->OnTouchEvent(motion_event);
+  return false;
+}
+
 void BlimpCompositor::WillBeginMainFrame() {}
 
 void BlimpCompositor::DidBeginMainFrame() {}
 
 void BlimpCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {}
 
 void BlimpCompositor::BeginMainFrameNotExpectedSoon() {}
 
 void BlimpCompositor::UpdateLayerTreeHost() {}
 
 void BlimpCompositor::ApplyViewportDeltas(
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {}
 
 void BlimpCompositor::RequestNewOutputSurface() {
   output_surface_request_pending_ = true;
   HandlePendingOutputSurfaceRequest();
 }
 
 void BlimpCompositor::DidInitializeOutputSurface() {

[David Trainor- moved to gerrit, 2015/12/03 16:14:04]

revert?

[Khushal, 2015/12/04 21:54:51]

Was this meant for another line?

 }
 
 void BlimpCompositor::DidFailToInitializeOutputSurface() {}
 
 void BlimpCompositor::WillCommit() {}
 
 void BlimpCompositor::DidCommit() {}
 
 void BlimpCompositor::DidCommitAndDrawFrame() {}
 
@@ skipping 15 matching lines @@
 }
 
 void BlimpCompositor::OnRenderWidgetInitialized() {
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   SetVisible(false);
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
+  // Destroy the old input manager state.
+  // It is important to destroy the LayerTreeHost before destroying the input
+  // manager as it has a reference to the cc::InputHandlerClient owned by the
+  // BlimpInputManager.
+  input_manager_.reset();
+
   // Reset other state.
   output_surface_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 void BlimpCompositor::OnCompositorMessageReceived(
     scoped_ptr<cc::proto::CompositorMessage> message) {
   // TODO(dtrainor, khushalsagar): Look into the CompositorMessage.  If it is
   // initialize or shutdown, create or destroy |host_|.
 
   // We should have a receiver if we're getting compositor messages that aren't
   // initialize.
   DCHECK(remote_proto_channel_receiver_);
   remote_proto_channel_receiver_->OnProtoReceived(std::move(message));
 }
 
 void BlimpCompositor::GenerateLayerTreeSettings(
     cc::LayerTreeSettings* settings) {
   PopulateCommonLayerTreeSettings(settings);
 }
 
+void BlimpCompositor::SendWebInputEvent(
+    const blink::WebInputEvent& input_event) {
+  render_widget_processor_.SendInputEvent(kDummyTabId, input_event);
+}
+
 void BlimpCompositor::CreateLayerTreeHost(
     scoped_ptr<cc::proto::CompositorMessage> message) {
   if (!settings_) {
     settings_.reset(new cc::LayerTreeSettings);
     GenerateLayerTreeSettings(settings_.get());
   }
 
   // Create the LayerTreeHost
   cc::LayerTreeHost::InitParams params;
   params.client = this;
@@ skipping 12 matching lines @@
     host_->SetVisible(true);
 
   host_->SetViewportSize(viewport_size_);
   host_->SetDeviceScaleFactor(device_scale_factor_);
 
   // For testing, set the dummy Layer.
   scoped_refptr<cc::Layer> root(
       cc::Layer::Create(BlimpCompositor::LayerSettings()));
   host_->SetRootLayer(root);
   g_dummy_layer_driver.Pointer()->SetParentLayer(root);
+
+  // TODO(khushalsagar): Create this after successful initialization of the
+  // remote client compositor when implemented.
+  DCHECK(!input_manager_);
+  input_manager_ =
+      BlimpInputManager::Create(this,
+                                base::ThreadTaskRunnerHandle::Get(),
+                                GetCompositorTaskRunner(),
+                                host_->GetInputHandler());
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 BlimpCompositor::GetCompositorTaskRunner() {
   if (compositor_thread_)
     return compositor_thread_->task_runner();
 
   base::Thread::Options thread_options;
 #if defined(OS_ANDROID)
   thread_options.priority = base::ThreadPriority::DISPLAY;
@@ skipping 29 matching lines @@
   output_surface_request_pending_ = false;
 }
 
 cc::LayerSettings BlimpCompositor::LayerSettings() {
   cc::LayerSettings settings;
   settings.use_compositor_animation_timelines = true;
   return settings;
 }
 
 }  // namespace blimp