Stop disabling force_compositing_mode for background RenderViews.

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/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
@@ skipping 330 matching lines @@
   params->x += offset_.x();
   params->y *= scale_;
   params->y += offset_.y();
 }
 
 // RenderWidget ---------------------------------------------------------------
 
 RenderWidget::RenderWidget(blink::WebPopupType popup_type,
                            const blink::WebScreenInfo& screen_info,
                            bool swapped_out,
-                           bool hidden)
+                           bool hidden,
+                           bool never_visible)
     : routing_id_(MSG_ROUTING_NONE),
       surface_id_(0),
       webwidget_(NULL),
       opener_id_(MSG_ROUTING_NONE),
       init_complete_(false),
       current_paint_buf_(NULL),
       overdraw_bottom_height_(0.f),
       next_paint_flags_(0),
       filtered_time_per_frame_(0.0f),
       update_reply_pending_(false),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       using_asynchronous_swapbuffers_(false),
       num_swapbuffers_complete_pending_(0),
       did_show_(false),
       is_hidden_(hidden),
+      never_visible_(never_visible),
       is_fullscreen_(false),
       needs_repainting_on_restore_(false),
       has_focus_(false),
       handling_input_event_(false),
       handling_ime_event_(false),
       handling_touchstart_event_(false),
       closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
@@ skipping 48 matching lines @@
   if (!is_swapped_out_ && RenderProcess::current())
     RenderProcess::current()->ReleaseProcess();
 }
 
 // static
 RenderWidget* RenderWidget::Create(int32 opener_id,
                                    blink::WebPopupType popup_type,
                                    const blink::WebScreenInfo& screen_info) {
   DCHECK(opener_id != MSG_ROUTING_NONE);
   scoped_refptr<RenderWidget> widget(
-      new RenderWidget(popup_type, screen_info, false, false));
+      new RenderWidget(popup_type, screen_info, false, false, false));
   if (widget->Init(opener_id)) {  // adds reference on success.
     return widget.get();
   }
   return NULL;
 }
 
 // static
 WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
   switch (render_widget->popup_type_) {
     case blink::WebPopupTypeNone:  // Nothing to create.
@@ skipping 46 matching lines @@
 
 // This is used to complete pending inits and non-pending inits.
 void RenderWidget::CompleteInit() {
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 
   init_complete_ = true;
 
   if (webwidget_ && is_threaded_compositing_enabled_) {
     webwidget_->enterForceCompositingMode(true);
   }
-  if (compositor_) {
-    compositor_->setSurfaceReady();
-  }
+  if (compositor_)
+    StartCompositor();
   DoDeferredUpdate();
 
   Send(new ViewHostMsg_RenderViewReady(routing_id_));
 }
 
 void RenderWidget::SetSwappedOut(bool is_swapped_out) {
   // We should only toggle between states.
   DCHECK(is_swapped_out_ != is_swapped_out);
   is_swapped_out_ = is_swapped_out;
 
@@ skipping 357 matching lines @@
 
 GURL RenderWidget::GetURLForGraphicsContext3D() {
   return GURL();
 }
 
 bool RenderWidget::ForceCompositingModeEnabled() {
   return false;
 }
 
 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_);
 
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
       SynchronousCompositorFactory::GetInstance()) {
     return factory->CreateOutputSurface(routing_id());
   }
 #endif
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool use_software = fallback;
@@ skipping 965 matching lines @@
 }
 
 void RenderWidget::initializeLayerTreeView() {
   compositor_ = RenderWidgetCompositor::Create(
       this, is_threaded_compositing_enabled_);
   if (!compositor_)
     return;
 
   compositor_->setViewportSize(size_, physical_backing_size_);
   if (init_complete_)
-    compositor_->setSurfaceReady();
+    StartCompositor();
 }
 
 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
   return compositor_.get();
 }
 
 void RenderWidget::suppressCompositorScheduling(bool enable) {
   if (compositor_)
     compositor_->SetSuppressScheduleComposite(enable);
 }
@@ skipping 772 matching lines @@
 #if defined(OS_ANDROID) || defined(USE_AURA)
   if (event_cancelled)
     return;
   if (event.type == WebInputEvent::GestureTap ||
       event.type == WebInputEvent::GestureLongPress) {
     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
   }
 #endif
 }
 
+void RenderWidget::StartCompositor() {
+  // For widgets that are never visible, we don't need the compositor to run
+  // at all.
+  if (never_visible_)
+    return;
+  compositor_->setSurfaceReady();
+}
+
 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;
       }
       break;
@@ skipping 148 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content