cc: Remove SetLayerTreeHostClientReady()

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <limits>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 196 matching lines @@
   compositor->Initialize();
   return compositor;
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidget* widget,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       widget_(widget),
       compositor_deps_(compositor_deps),
+      never_visible_(false),
       layout_and_paint_async_callback_(nullptr),
       weak_factory_(this) {
 }
 
 void RenderWidgetCompositor::Initialize() {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // For web contents, layer transforms should scale up the contents of layers
@@ skipping 265 matching lines @@
     layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
         compositor_thread_task_runner, &params);
   } else {
     layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   }
   DCHECK(layer_tree_host_);
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 
+void RenderWidgetCompositor::SetNeverVisible() {
+  DCHECK(!layer_tree_host_->visible());
+  never_visible_ = true;
+}
+
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
   return layer_tree_host_->BeginMainFrameRequested();
 }
 
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
@@ skipping 54 matching lines @@
     const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
   return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
 }
 
 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
     int id,
     scoped_ptr<base::Value> value) {
   return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
-void RenderWidgetCompositor::StartCompositor() {
-  layer_tree_host_->SetLayerTreeHostClientReady();
-}
-
 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
   layer_tree_host_->SetRootLayer(
       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 }
 
 void RenderWidgetCompositor::attachCompositorAnimationTimeline(
@@ skipping 36 matching lines @@
 
 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
   layer_tree_host_->set_background_color(color);
 }
 
 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
   layer_tree_host_->set_has_transparent_background(transparent);
 }
 
 void RenderWidgetCompositor::setVisible(bool visible) {
+  if (never_visible_)
+    return;
+
   layer_tree_host_->SetVisible(visible);
 }
 
 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
     float page_scale_factor, float minimum, float maximum) {
   layer_tree_host_->SetPageScaleFactorAndLimits(
       page_scale_factor, minimum, maximum);
 }
 
 void RenderWidgetCompositor::startPageScaleAnimation(
@@ skipping 439 matching lines @@
   // Ignore what the system said and give all clients the same maximum
   // allocation on desktop platforms.
   actual.bytes_limit_when_visible = 512 * 1024 * 1024;
   actual.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 #endif
   return actual;
 }
 
 }  // namespace content