Remove some legacy software WebWidgetClient callbacks from RenderWidget

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 368 matching lines @@
       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),
-      invalidation_task_posted_(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)
       cached_has_main_frame_horizontal_scrollbar_(false),
       cached_has_main_frame_vertical_scrollbar_(false),
 #endif
       popup_origin_scale_for_emulation_(0.f),
       resizing_mode_selector_(new ResizingModeSelector()),
       context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   is_threaded_compositing_enabled_ =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableThreadedCompositing);
-
-  legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          cc::switches::kEnableGpuBenchmarking))
-    legacy_software_mode_stats_->set_record_rendering_stats(true);
 }
 
 RenderWidget::~RenderWidget() {
   DCHECK(!webwidget_) << "Leaking our WebWidget!";
 
   // If we are swapped out, we have released already.
   if (!is_swapped_out_ && RenderProcess::current())
     RenderProcess::current()->ReleaseProcess();
 }
 
@@ skipping 709 matching lines @@
     webwidget_->setFocus(enable);
 }
 
 void RenderWidget::ClearFocus() {
   // We may have got the focus from the browser before this gets processed, in
   // which case we do not want to unfocus ourself.
   if (!has_focus_ && webwidget_)
     webwidget_->setFocus(false);
 }
 
-void RenderWidget::InvalidationCallback() {
-  TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
-  invalidation_task_posted_ = false;
-  FlushPendingInputEventAck();
-}
-
 void RenderWidget::FlushPendingInputEventAck() {
   if (pending_input_event_ack_)
     Send(pending_input_event_ack_.release());
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebWidgetClient
 
-void RenderWidget::didInvalidateRect(const WebRect& rect) {

[piman, 2014/05/12 23:55:21]

There are still paths in WebKit that call didInvalidateRect/didScrollRect. In
particular for popups.

Now, I think they shouldn't, but I'm not sure we can blindly remove these?
Or do we know that they're redundant with the compositor-based mechanisms?

-  // The invalidated rect might be outside the bounds of the view.
-  gfx::Rect view_rect(size_);
-  gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
-  if (damaged_rect.IsEmpty())
-    return;
-
-  // We may not need to schedule another call to DoDeferredUpdate.
-  if (invalidation_task_posted_)
-    return;
-
-  // Perform updating asynchronously.  This serves two purposes:
-  // 1) Ensures that we call WebView::Paint without a bunch of other junk
-  //    on the call stack.
-  // 2) Allows us to collect more damage rects before painting to help coalesce
-  //    the work that we will need to do.
-  invalidation_task_posted_ = true;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
-}
-
-void RenderWidget::didScrollRect(int dx, int dy,
-                                 const WebRect& clip_rect) {
-  // Drop scrolls on the floor when we are in compositing mode.
-  // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
-  if (is_accelerated_compositing_active_)
-    return;
-
-  // The scrolled rect might be outside the bounds of the view.
-  gfx::Rect view_rect(size_);
-  gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
-  if (damaged_rect.IsEmpty())
-    return;
-
-  // We may not need to schedule another call to DoDeferredUpdate.
-  if (invalidation_task_posted_)
-    return;
-
-  // Perform updating asynchronously.  This serves two purposes:
-  // 1) Ensures that we call WebView::Paint without a bunch of other junk
-  //    on the call stack.
-  // 2) Allows us to collect more damage rects before painting to help coalesce
-  //    the work that we will need to do.
-  invalidation_task_posted_ = true;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
-}
-
 void RenderWidget::didAutoResize(const WebSize& new_size) {
   if (size_.width() != new_size.width || size_.height() != new_size.height) {
     size_ = new_size;
 
     if (resizing_mode_selector_->is_synchronous_mode()) {
       WebRect new_pos(rootWindowRect().x,
                       rootWindowRect().y,
                       new_size.width,
                       new_size.height);
       view_screen_rect_ = new_pos;
@@ skipping 107 matching lines @@
   Send(new ViewHostMsg_UpdateRect(routing_id_, params));
   next_paint_flags_ = 0;
   need_update_rect_for_auto_resize_ = false;
 }
 
 void RenderWidget::scheduleComposite() {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   // render_thread may be NULL in tests.
   if (render_thread && render_thread->compositor_message_loop_proxy().get() &&
       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));
+    compositor_->setNeedsAnimate();
   }
 }
 
 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;
@@ skipping 828 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content