Unifies LayerTreeHost::SetNeedsUpdateLayers and SetNeedsAnimate

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/logging.h"
@@ skipping 544 matching lines @@
     ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
   popup->SetOriginScaleAndOffsetForEmulation(
       emulator->scale(), emulator->offset());
 }
 
 void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
   if (screen_metrics_emulator_)
     screen_metrics_emulator_->OnShowContextMenu(params);
 }
 
+void RenderWidget::ScheduleAnimation() {
+  if (animation_update_pending_)
+    return;
+
+  TRACE_EVENT0("gpu", "RenderWidget::ScheduleAnimation");
+  animation_update_pending_ = true;
+  if (!animation_timer_.IsRunning()) {
+    animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
+                           &RenderWidget::AnimationCallback);
+  }
+}
+
+void RenderWidget::ScheduleComposite() {
+  if (is_accelerated_compositing_active_ &&
+      RenderThreadImpl::current()->compositor_message_loop_proxy().get()) {
+    DCHECK(compositor_);
+    compositor_->setNeedsAnimate();
+  } else {
+    // TODO(nduca): replace with something a little less hacky.  The reason this
+    // hack is still used is because the Invalidate-DoDeferredUpdate loop
+    // contains a lot of host-renderer synchronization logic that is still
+    // important for the accelerated compositing case. The option of simply
+    // duplicating all that code is less desirable than "faking out" the
+    // invalidation path using a magical damage rect.
+    didInvalidateRect(WebRect(0, 0, 1, 1));
+  }
+}
+
 void RenderWidget::ScheduleCompositeWithForcedRedraw() {
   if (compositor_) {
     // Regardless of whether threaded compositing is enabled, always
     // use this mechanism to force the compositor to redraw. However,
     // the invalidation code path below is still needed for the
     // non-threaded case.
     compositor_->SetNeedsForcedRedraw();
   }
-  scheduleComposite();
+  ScheduleComposite();
 }
 
 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
                         OnCursorVisibilityChange)
     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
@@ skipping 214 matching lines @@
   needs_repainting_on_restore_ = false;
 
   // Tag the next paint as a restore ack, which is picked up by
   // DoDeferredUpdate when it sends out the next PaintRect message.
   set_next_paint_is_restore_ack();
 
   // Generate a full repaint.
   if (!is_accelerated_compositing_active_) {
     didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
   } else {
-    if (compositor_)
-      compositor_->SetNeedsForcedRedraw();
-    scheduleComposite();
+    ScheduleCompositeWithForcedRedraw();
   }
 }
 
 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 139 matching lines @@
     ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
     updates_pending_swap_.pop_front();
     // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
     // compositing pass, hence doesn't require an UpdateRect message.
     if (msg)
       Send(msg);
   }
   num_swapbuffers_complete_pending_ = 0;
   using_asynchronous_swapbuffers_ = false;
   // Schedule another frame so the compositor learns about it.
-  scheduleComposite();
+  ScheduleComposite();
 }
 
 void RenderWidget::OnSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 
   if (using_asynchronous_swapbuffers_) {
     ViewHostMsg_UpdateRect* msg = NULL;
     // pending_update_params_ can be NULL if the swap doesn't correspond to an
     // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
     // message.
@@ skipping 935 matching lines @@
   params.flags = next_paint_flags_;
   params.scroll_offset = GetScrollOffset();
   params.needs_ack = false;
   params.scale_factor = device_scale_factor_;
 
   Send(new ViewHostMsg_UpdateRect(routing_id_, params));
   next_paint_flags_ = 0;
   need_update_rect_for_auto_resize_ = false;
 }
 
-void RenderWidget::scheduleComposite() {
-  if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
-      compositor_) {
-      compositor_->setNeedsAnimate();
+// Renamed. Staged for removal.
+void RenderWidget::scheduleAnimation() { scheduleUpdate(); }
+
+void RenderWidget::scheduleUpdate() {
+  if (is_accelerated_compositing_active_) {
+    DCHECK(compositor_);
+    compositor_->setNeedsUpdateLayers();
   } else {
-    // TODO(nduca): replace with something a little less hacky.  The reason this
-    // hack is still used is because the Invalidate-DoDeferredUpdate loop
-    // contains a lot of host-renderer synchronization logic that is still
-    // important for the accelerated compositing case. The option of simply
-    // duplicating all that code is less desirable than "faking out" the
-    // invalidation path using a magical damage rect.
-    didInvalidateRect(WebRect(0, 0, 1, 1));
+    ScheduleAnimation();
   }
 }
 
-void RenderWidget::scheduleAnimation() {
-  if (animation_update_pending_)
-    return;
-
-  TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
-  animation_update_pending_ = true;
-  if (!animation_timer_.IsRunning()) {
-    animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
-                           &RenderWidget::AnimationCallback);
-  }
-}
-
 void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
   // TODO(darin): Eliminate this temporary.
   WebCursor cursor;
   InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
   // Only send a SetCursor message if we need to make a change.
   if (!current_cursor_.IsEqual(cursor)) {
     current_cursor_ = cursor;
     Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
   }
 }
@@ skipping 382 matching lines @@
 
 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();
   }
 }
 
 PepperPluginInstanceImpl* RenderWidget::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip,
     float* scale_factor) {
   // Bare RenderWidgets don't support optimized plugin painting.
@@ skipping 494 matching lines @@
           surface_id(),
           GetURLForGraphicsContext3D(),
           gpu_channel_host.get(),
           attributes,
           false /* bind generates resources */,
           limits));
   return context.Pass();
 }
 
 }  // namespace content