Move BlimpInputManager to BlimpDocument from BlimpCompositor.

blimp/client/core/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/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 75 matching lines @@
   CheckPendingCommitCounts(true /* flush */);
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
 
   if (!visible)
     CheckPendingCommitCounts(true /* flush */);
 }
 
-bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
-  if (input_manager_)
-    return input_manager_->OnTouchEvent(motion_event);
-  return false;
-}
-
 void BlimpCompositor::NotifyWhenDonePendingCommits(base::Closure callback) {
   if (outstanding_commits_ == 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
     return;
   }
 
   pending_commit_trackers_.push_back(
       std::make_pair(outstanding_commits_, callback));
 }
 
@@ skipping 49 matching lines @@
       UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
                               (float)message->ByteSize() / 1024);
     default:
       // We should have a receiver if we're getting compositor messages that
       // are not INITIALIZE_IMPL or CLOSE_IMPL.
       DCHECK(remote_proto_channel_receiver_);
       remote_proto_channel_receiver_->OnProtoReceived(std::move(message));
   }
 }
 
+// Returns a reference to the InputHandler owned by layer tree host.
+const base::WeakPtr<cc::InputHandler>& BlimpCompositor::GetInputHandler() {
+  return host_->GetInputHandler();
+}
+
 void BlimpCompositor::OnContextProvidersCreated(
     const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
     const scoped_refptr<cc::ContextProvider>& worker_context_provider) {
   DCHECK(!surface_factory_) << "Any connection to the old CompositorFrameSink "
                                "should have been destroyed";
 
   // Make sure we still have a host and we're still expecting a
   // CompositorFrameSink. This can happen if the host dies while the request is
   // outstanding and we build a new one that hasn't asked for a surface yet.
   if (!compositor_frame_sink_request_pending_)
     return;
 
   // Try again if the context creation failed.
   if (!compositor_context_provider) {
     GetEmbedderDeps()->GetContextProviders(
         base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                    weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   auto compositor_frame_sink = base::MakeUnique<BlimpCompositorFrameSink>(
       std::move(compositor_context_provider),
       std::move(worker_context_provider), base::ThreadTaskRunnerHandle::Get(),
       weak_ptr_factory_.GetWeakPtr());
 
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
-void BlimpCompositor::SendWebGestureEvent(
-    const blink::WebGestureEvent& gesture_event) {
-  client_->SendWebGestureEvent(gesture_event);
-}
-
 void BlimpCompositor::BindToProxyClient(
     base::WeakPtr<BlimpCompositorFrameSinkProxyClient> proxy_client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_factory_);
 
   proxy_client_ = proxy_client;
   surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(
       frame_sink_id_, GetEmbedderDeps()->GetSurfaceManager(), this);
 }
 
@@ skipping 88 matching lines @@
   settings->abort_commit_before_compositor_frame_sink_creation = false;
   params.settings = settings;
 
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
   host_ = cc::LayerTreeHostInProcess::CreateRemoteClient(
       this /* remote_proto_channel */, compositor_task_runner, &params);
-
-  DCHECK(!input_manager_);
-  input_manager_ = BlimpInputManager::Create(
-      this, base::ThreadTaskRunnerHandle::Get(), compositor_task_runner,
-      host_->GetInputHandler());
 }
 
 void BlimpCompositor::DestroyLayerTreeHost() {
   DCHECK(host_);
   VLOG(1) << "Destroying LayerTreeHost.";
 
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   DestroyDelegatedContent();
   surface_factory_.reset();
 
   // 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();
-
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 void BlimpCompositor::CheckPendingCommitCounts(bool flush) {
   for (auto it = pending_commit_trackers_.begin();
        it != pending_commit_trackers_.end();) {
     if (flush || --it->first == 0) {
       it->second.Run();
       it = pending_commit_trackers_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 }  // namespace client
 }  // namespace blimp