Move compositor thread input handling logic into content

cc/trees/thread_proxy.cc

 // Copyright 2011 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 "cc/trees/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 495 matching lines @@
 
 void ThreadProxy::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
   Proxy::ImplThread()->PostTask(
       base::Bind(&ThreadProxy::MainThreadHasStoppedFlingingOnImplThread,
                  impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::MainThreadHasStoppedFlingingOnImplThread() {
   DCHECK(IsImplThread());
-  if (input_handler_client_on_impl_thread_)
-    input_handler_client_on_impl_thread_->MainThreadHasStoppedFlinging();
+  layer_tree_host_impl_->MainThreadHasStoppedFlinging();
 }
 
 void ThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
   DCHECK(IsMainThread());
   DCHECK(Proxy::ImplThread());
   DCHECK(first_output_surface);
   // Create LayerTreeHostImpl.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  scoped_ptr<InputHandlerClient> input_handler_client =
-      layer_tree_host_->CreateInputHandlerClient();
   Proxy::ImplThread()->PostTask(
       base::Bind(&ThreadProxy::InitializeImplOnImplThread,
                  base::Unretained(this),
-                 &completion,
-                 input_handler_client.release()));
+                 &completion));
   completion.Wait();
 
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
   first_output_surface_ = first_output_surface.Pass();
 
   started_ = true;
 }
 
 void ThreadProxy::Stop() {
   TRACE_EVENT0("cc", "ThreadProxy::Stop");
@@ skipping 341 matching lines @@
     return result;
 
   DCHECK(layer_tree_host_impl_->renderer());
   if (!layer_tree_host_impl_->renderer())
     return result;
 
   base::TimeTicks monotonic_time =
       layer_tree_host_impl_->CurrentFrameTimeTicks();
   base::Time wall_clock_time = layer_tree_host_impl_->CurrentFrameTime();
 
-  if (input_handler_client_on_impl_thread_)
-    input_handler_client_on_impl_thread_->Animate(monotonic_time);
-
   layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
   layer_tree_host_impl_->Animate(monotonic_time, wall_clock_time);
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(false);
 
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
   // request completes, and we signal completion here. If CanDraw() is false, we
   // will indicate success=false to the caller, but we must still signal
   // completion to avoid deadlock.
 
@@ skipping 185 matching lines @@
 
 void ThreadProxy::HasInitializedOutputSurfaceOnImplThread(
     CompletionEvent* completion,
     bool* has_initialized_output_surface) {
   DCHECK(IsImplThread());
   *has_initialized_output_surface =
       scheduler_on_impl_thread_->HasInitializedOutputSurface();
   completion->Signal();
 }
 
-void ThreadProxy::InitializeImplOnImplThread(
-    CompletionEvent* completion,
-    InputHandlerClient* input_handler_client) {
+void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           layer_tree_host_->settings().refresh_rate);
   scoped_ptr<FrameRateController> frame_rate_controller;
   if (render_vsync_enabled_) {
     if (render_vsync_notification_enabled_) {
@@ skipping 10 matching lines @@
   const LayerTreeSettings& settings = layer_tree_host_->settings();
   SchedulerSettings scheduler_settings;
   scheduler_settings.impl_side_painting = settings.impl_side_painting;
   scheduler_settings.timeout_and_draw_when_animation_checkerboards =
       settings.timeout_and_draw_when_animation_checkerboards;
   scheduler_on_impl_thread_ = Scheduler::Create(this,
                                                 frame_rate_controller.Pass(),
                                                 scheduler_settings);
   scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 
-  input_handler_client_on_impl_thread_.reset(input_handler_client);
-  if (input_handler_client_on_impl_thread_) {
-    input_handler_client_on_impl_thread_->BindToHandler(
-        layer_tree_host_impl_.get());
-  }
-
   impl_thread_weak_ptr_ = weak_factory_on_impl_thread_.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     CompletionEvent* completion,
     scoped_ptr<OutputSurface> output_surface,
     scoped_refptr<ContextProvider> offscreen_context_provider,
     bool* success,
     RendererCapabilities* capabilities) {
@@ skipping 45 matching lines @@
     layer_tree_host_impl_->resource_provider()->Finish();
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
   layer_tree_host_impl_->EnableVSyncNotification(false);
-  input_handler_client_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   scheduler_on_impl_thread_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
   vsync_client_ = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
@@ skipping 149 matching lines @@
 
 void ThreadProxy::DidReceiveLastInputEventForVSync(
     base::TimeTicks frame_time) {
   if (render_vsync_notification_enabled_) {
     TRACE_EVENT0("cc", "ThreadProxy::DidReceiveLastInputEventForVSync");
     DidVSync(frame_time);
   }
 }
 
 }  // namespace cc