Remove renderer-side tracking of accelerated compositing

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 365 matching lines @@
       handling_touchstart_event_(false),
       closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       can_compose_inline_(true),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
-      is_accelerated_compositing_active_(false),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       is_threaded_compositing_enabled_(false),
       next_output_surface_id_(0),
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
       outstanding_ime_acks_(0),
       body_background_color_(SK_ColorWHITE),
 #endif
 #if defined(OS_MACOSX)
@@ skipping 82 matching lines @@
     return false;
   }
 }
 
 // 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_) {
-    if (is_threaded_compositing_enabled_ || ForceCompositingModeEnabled()) {
-      webwidget_->enterForceCompositingMode(true);
-    }
-  }
+  if (webwidget_)
+    webwidget_->enterForceCompositingMode(true);
   if (compositor_)
     StartCompositor();
 
   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 273 matching lines @@
   if (!webwidget_)
     return;
 
   // See OnWasHidden
   SetHidden(false);
 
   if (!needs_repainting)
     return;
 
   // Generate a full repaint.
-  if (!is_accelerated_compositing_active_) {
-    didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
-  } else {
-    if (compositor_)
-      compositor_->SetNeedsForcedRedraw();
-    scheduleComposite();
-  }
+  if (compositor_)
+    compositor_->SetNeedsForcedRedraw();
+  scheduleComposite();
 }
 
 void RenderWidget::OnWasSwappedOut() {
   // If we have been swapped out and no one else is using this process,
   // it's safe to exit now.  If we get swapped back in, we will call
   // AddRefProcess in SetSwappedOut.
   if (is_swapped_out_)
     RenderProcess::current()->ReleaseProcess();
 }
 
@@ skipping 361 matching lines @@
   }
 }
 
 void RenderWidget::AutoResizeCompositor()  {
   physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
       device_scale_factor_));
   if (compositor_)
     compositor_->setViewportSize(size_, physical_backing_size_);
 }
 
-void RenderWidget::didActivateCompositor() {
-  TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
-
-  is_accelerated_compositing_active_ = true;
-  webwidget_->enterForceCompositingMode(true);
-}
-
-void RenderWidget::didDeactivateCompositor() {
-  TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
-
-  is_accelerated_compositing_active_ = false;
-}
-
 void RenderWidget::initializeLayerTreeView() {
   compositor_ = RenderWidgetCompositor::Create(
       this, is_threaded_compositing_enabled_);
   compositor_->setViewportSize(size_, physical_backing_size_);
   if (init_complete_)
     StartCompositor();
 }
 
 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
   return compositor_.get();
@@ skipping 280 matching lines @@
   if (!webwidget_)
     return;
 
   // Even if the browser provides an empty damage rect, it's still expecting to
   // receive a repaint ack so just damage the entire widget bounds.
   if (size_to_paint.IsEmpty()) {
     size_to_paint = size_;
   }
 
   set_next_paint_is_repaint_ack();
-  if (is_accelerated_compositing_active_ && compositor_) {
+  if (compositor_)
     compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
-  } else {
-    gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
-    didInvalidateRect(repaint_rect);
-  }
 }
 
 void RenderWidget::OnSyntheticGestureCompleted() {
   DCHECK(!pending_synthetic_gesture_callbacks_.empty());
 
   pending_synthetic_gesture_callbacks_.front().Run();
   pending_synthetic_gesture_callbacks_.pop();
 }
 
 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
@@ skipping 35 matching lines @@
 #else
   return !!webwidget_;
 #endif
 }
 
 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
-
-  if (!is_accelerated_compositing_active_) {
-    didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
-  } else {
-    scheduleComposite();
-  }
+  scheduleComposite();
 }
 
 void RenderWidget::OnOrientationChange() {
 }
 
 gfx::Vector2d RenderWidget::GetScrollOffset() {
   // Bare RenderWidgets don't support scroll offset.
   return gfx::Vector2d();
 }
 
@@ skipping 538 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content