Add BlimpDocument, pull out functions in 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 40 matching lines @@
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
 BlimpCompositor::BlimpCompositor(
-    int render_widget_id,
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client)
-    : render_widget_id_(render_widget_id),
-      client_(client),
+    : client_(client),
       compositor_dependencies_(compositor_dependencies),
       proxy_client_(nullptr),
       compositor_frame_sink_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       outstanding_commits_(0U),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
@@ skipping 58 matching lines @@
 
   CheckPendingCommitCounts(false /* flush */);
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   remote_proto_channel_receiver_ = receiver;
 }
 
 void BlimpCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
-  client_->SendCompositorMessage(render_widget_id_, proto);
+  client_->SendCompositorMessage(proto);
 }
 
 void BlimpCompositor::OnCompositorMessageReceived(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   DCHECK(message->has_to_impl());
   const cc::proto::CompositorMessageToImpl& to_impl_proto = message->to_impl();
 
   DCHECK(to_impl_proto.has_message_type());
 
   if (to_impl_proto.message_type() ==
@@ skipping 39 matching lines @@
   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(render_widget_id_, 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>(
       GetEmbedderDeps()->GetSurfaceManager(), this);
@@ skipping 61 matching lines @@
     return;
 
   // Remove any references for the surface layer that uses this |surface_id_|.
   layer_->RemoveAllChildren();
   surface_factory_->Destroy(surface_id_);
   surface_id_ = cc::SurfaceId();
 }
 
 void BlimpCompositor::CreateLayerTreeHost() {
   DCHECK(!host_);
-  VLOG(1) << "Creating LayerTreeHost for render widget: " << render_widget_id_;
+  VLOG(1) << "Creating LayerTreeHost.";
 
   // Create the LayerTreeHost
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
   params.gpu_memory_buffer_manager =
       GetEmbedderDeps()->GetGpuMemoryBufferManager();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.image_serialization_processor =
       compositor_dependencies_->GetImageSerializationProcessor();
@@ skipping 14 matching lines @@
       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 for render widget: "
-          << render_widget_id_;
+  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
@@ skipping 16 matching lines @@
       it->second.Run();
       it = pending_commit_trackers_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 }  // namespace client
 }  // namespace blimp