cc: Remove SetLayerTreeHostClientReady()

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 474 matching lines @@
       compositor_deps_(compositor_deps),
       webwidget_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
-      never_visible_(never_visible),
+      compositor_never_visible_(never_visible),
       is_fullscreen_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
       has_focus_(false),
       handling_input_event_(false),
       handling_event_overscroll_(nullptr),
       handling_ime_event_(false),
       handling_event_type_(WebInputEvent::Undefined),
       ignore_ack_for_mouse_move_from_debugger_(false),
       closing_(false),
       host_closing_(false),
@@ skipping 454 matching lines @@
   pending_window_rect_count_--;
 }
 
 GURL RenderWidget::GetURLForGraphicsContext3D() {
   return GURL();
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
-  DCHECK(!never_visible_);
+  DCHECK(!compositor_never_visible_);
 
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
       SynchronousCompositorFactory::GetInstance()) {
     return factory->CreateOutputSurface(routing_id(),
                                         frame_swap_message_queue_);
   }
 #endif
 
   const base::CommandLine& command_line =
@@ skipping 351 matching lines @@
   physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
   if (compositor_)
     compositor_->setViewportSize(size_, physical_backing_size_);
 }
 
 void RenderWidget::initializeLayerTreeView() {
   DCHECK(!host_closing_);
 
   compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
   compositor_->setViewportSize(size_, physical_backing_size_);
+
+  // For background pages and certain tests, we don't want to trigger
+  // OutputSurface creation.
+  if (compositor_never_visible_ || !RenderThreadImpl::current())
+    compositor_->SetNeverVisible();
+
   StartCompositor();
 }
 
 void RenderWidget::WillCloseLayerTreeView() {
   if (host_closing_)
     return;
 
   // Prevent new compositors or output surfaces from being created.
   host_closing_ = true;
 
@@ skipping 809 matching lines @@
   // it can be bundled in the event ack.
   if (handling_event_overscroll_) {
     handling_event_overscroll_->reset(new DidOverscrollParams(params));
     return;
   }
 
   Send(new InputHostMsg_DidOverscroll(routing_id_, params));
 }
 
 void RenderWidget::StartCompositor() {
-  // For widgets that are never visible, we don't need the compositor to run
-  // at all.
-  if (never_visible_)
-    return;
-  // In tests without a RenderThreadImpl, don't set ready as this kicks
-  // off creating output surfaces that the test can't create.
-  if (!RenderThreadImpl::current())
-    return;
-  compositor_->StartCompositor();
+  if (!is_hidden())
+    compositor_->setVisible(true);
 }
 
 void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
   size_t i = 0;
   for (; i < plugin_window_moves_.size(); ++i) {
     if (plugin_window_moves_[i].window == move.window) {
       if (move.rects_valid) {
         plugin_window_moves_[i] = move;
       } else {
         plugin_window_moves_[i].visible = move.visible;
@@ skipping 190 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content