cc/blimp: Remove Initialize and Close messages.

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/numerics/safe_conversions.h"
@@ skipping 45 matching lines @@
 
 }  // namespace
 
 BlimpCompositor::BlimpCompositor(
     int render_widget_id,
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client)
     : render_widget_id_(render_widget_id),
       client_(client),
       compositor_dependencies_(compositor_dependencies),
-      host_should_be_visible_(false),
       output_surface_(nullptr),
       output_surface_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
       GetEmbedderDeps()->AllocateSurfaceClientId());
   GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
+  CreateLayerTreeHost();
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (host_)
-    DestroyLayerTreeHost();
-
+  DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
-  host_should_be_visible_ = visible;
-  if (host_)
-    host_->SetVisible(host_should_be_visible_);
+  host_->SetVisible(visible);
 }
 
 bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
   if (input_manager_)
     return input_manager_->OnTouchEvent(motion_event);
   return false;
 }
 
 void BlimpCompositor::RequestNewOutputSurface() {
   DCHECK(!surface_factory_);
@@ skipping 25 matching lines @@
 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());
   switch (to_impl_proto.message_type()) {
     case cc::proto::CompositorMessageToImpl::UNKNOWN:
       NOTIMPLEMENTED() << "Ignoring message of UNKNOWN type";
       break;
-    case cc::proto::CompositorMessageToImpl::INITIALIZE_IMPL:
-      DCHECK(!host_);
-
-      // Create the remote client LayerTreeHost for the compositor.
-      CreateLayerTreeHost();
-      break;
-    case cc::proto::CompositorMessageToImpl::CLOSE_IMPL:
-      DCHECK(host_);
-
-      // Destroy the remote client LayerTreeHost for the compositor.
-      DestroyLayerTreeHost();
-      break;
     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));
   }
 }
 
 void BlimpCompositor::OnContextProvidersCreated(
     const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
@@ skipping 125 matching lines @@
   settings->abort_commit_before_output_surface_creation = false;
   params.settings = settings;
 
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
   host_ = cc::LayerTreeHost::CreateRemoteClient(
       this /* remote_proto_channel */, compositor_task_runner, &params);
-  host_->SetVisible(host_should_be_visible_);
 
   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: "
@@ skipping 15 matching lines @@
   // Cancel any outstanding OutputSurface requests.  That way if we get an async
   // callback related to the old request we know to drop it.
   output_surface_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp