Turn off computation of the interest rect in cc in synchronized paint mode.

cc/playback/display_list_recording_source.cc

 // Copyright 2014 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 "cc/playback/display_list_recording_source.h"
 
 #include <algorithm>
 
 #include "base/numerics/safe_math.h"
 #include "cc/base/histograms.h"
 #include "cc/base/region.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/display_list_raster_source.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 
-// Layout pixel buffer around the visible layer rect to record.  Any base
-// picture that intersects the visible layer rect expanded by this distance
-// will be recorded.
-const int kPixelDistanceToRecord = 4000;
-
-// This is the distance, in layer space, by which the recorded viewport has to
-// change before causing a paint of the new content. For example, it means
-// that one has to scroll a very large page by 512 pixels before we will
-// re-record a new DisplayItemList for an updated recorded viewport.
-const int kMinimumDistanceBeforeUpdatingRecordedViewport = 512;
-
 #ifdef NDEBUG
 const bool kDefaultClearCanvasSetting = false;
 #else
 const bool kDefaultClearCanvasSetting = true;
 #endif
 
 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     ScopedDisplayListRecordingSourceUpdateTimer,
     "Compositing.%s.DisplayListRecordingSource.UpdateUs",
     "Compositing.%s.DisplayListRecordingSource.UpdateInvalidatedAreaPerMs");
 
 }  // namespace
 
 namespace cc {
 
 DisplayListRecordingSource::DisplayListRecordingSource()
     : slow_down_raster_scale_factor_for_debug_(0),
       generate_discardable_images_metadata_(false),
       requires_clear_(false),
       is_solid_color_(false),
       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
       solid_color_(SK_ColorTRANSPARENT),
       background_color_(SK_ColorTRANSPARENT),
-      pixel_record_distance_(kPixelDistanceToRecord),
       painter_reported_memory_usage_(0) {}
 
 DisplayListRecordingSource::~DisplayListRecordingSource() {
 }
 
-// This method only really makes sense to call if the size of the layer didn't
-// change.
-bool DisplayListRecordingSource::ExposesEnoughNewArea(
-    const gfx::Rect& current_recorded_viewport,
-    const gfx::Rect& potential_new_recorded_viewport,
-    const gfx::Size& layer_size) {
-  // If both are empty, nothing to do.
-  if (current_recorded_viewport.IsEmpty() &&
-      potential_new_recorded_viewport.IsEmpty())
-    return false;
+void DisplayListRecordingSource::UpdateInvalidationForNewViewport(
+    const gfx::Rect& old_recorded_viewport,
+    const gfx::Rect& new_recorded_viewport,
+    Region* invalidation) {
+  // Invalidate newly-exposed and no-longer-exposed areas.
+  Region newly_exposed_region(new_recorded_viewport);
+  newly_exposed_region.Subtract(old_recorded_viewport);
+  invalidation->Union(newly_exposed_region);
 
-  // Re-record when going from empty to not-empty, to cover cases where
-  // the layer is recorded for the first time, or otherwise becomes visible.
-  if (current_recorded_viewport.IsEmpty())
-    return true;
-
-  // Re-record if the new viewport includes area outside of a skirt around the
-  // existing viewport.
-  gfx::Rect expanded_viewport(current_recorded_viewport);
-  expanded_viewport.Inset(-kMinimumDistanceBeforeUpdatingRecordedViewport,
-                          -kMinimumDistanceBeforeUpdatingRecordedViewport);
-  if (!expanded_viewport.Contains(potential_new_recorded_viewport))
-    return true;
-
-  // Even if the new viewport doesn't include enough new area to satisfy the
-  // condition above, re-record anyway if touches a layer edge not touched by
-  // the existing viewport. Viewports are clipped to layer boundaries, so if the
-  // new viewport touches a layer edge not touched by the existing viewport,
-  // the new viewport must expose new area that touches this layer edge. Since
-  // this new area touches a layer edge, it's impossible to expose more area in
-  // that direction, so recording cannot be deferred until the exposed new area
-  // satisfies the condition above.
-  if (potential_new_recorded_viewport.x() == 0 &&
-      current_recorded_viewport.x() != 0)
-    return true;
-  if (potential_new_recorded_viewport.y() == 0 &&
-      current_recorded_viewport.y() != 0)
-    return true;
-  if (potential_new_recorded_viewport.right() == layer_size.width() &&
-      current_recorded_viewport.right() != layer_size.width())
-    return true;
-  if (potential_new_recorded_viewport.bottom() == layer_size.height() &&
-      current_recorded_viewport.bottom() != layer_size.height())
-    return true;
-
-  return false;
+  Region no_longer_exposed_region(old_recorded_viewport);
+  no_longer_exposed_region.Subtract(new_recorded_viewport);
+  invalidation->Union(no_longer_exposed_region);
 }
 
 bool DisplayListRecordingSource::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
     RecordingMode recording_mode) {
   ScopedDisplayListRecordingSourceUpdateTimer timer;
   bool updated = false;
 
+  // TODO(chrishtr): delete this conditional once synchronized paint launches.
   if (size_ != layer_size) {
     size_ = layer_size;
     updated = true;
   }
 
-  // The recorded viewport is the visible layer rect, expanded
-  // by the pixel record distance, up to a maximum of the total
-  // layer size.
-  gfx::Rect potential_new_recorded_viewport = visible_layer_rect;
-  potential_new_recorded_viewport.Inset(-pixel_record_distance_,
-                                        -pixel_record_distance_);
-  potential_new_recorded_viewport.Intersect(gfx::Rect(GetSize()));
-
-  if (updated ||
-      ExposesEnoughNewArea(recorded_viewport_, potential_new_recorded_viewport,
-                           GetSize())) {
-    gfx::Rect old_recorded_viewport = recorded_viewport_;
-    recorded_viewport_ = potential_new_recorded_viewport;
-
-    // Invalidate newly-exposed and no-longer-exposed areas.
-    Region newly_exposed_region(recorded_viewport_);
-    newly_exposed_region.Subtract(old_recorded_viewport);
-    invalidation->Union(newly_exposed_region);
-
-    Region no_longer_exposed_region(old_recorded_viewport);
-    no_longer_exposed_region.Subtract(recorded_viewport_);
-    invalidation->Union(no_longer_exposed_region);
-
+  gfx::Rect new_recorded_viewport = painter->PaintableRegion();
+  if (new_recorded_viewport != recorded_viewport_) {
+    UpdateInvalidationForNewViewport(recorded_viewport_, new_recorded_viewport,
+                                     invalidation);
+    recorded_viewport_ = new_recorded_viewport;
     updated = true;
   }
 
   // Count the area that is being invalidated.
   Region recorded_invalidation(*invalidation);
   recorded_invalidation.Intersect(recorded_viewport_);
   for (Region::Iterator it(recorded_invalidation); it.has_rect(); it.next())
     timer.AddArea(it.rect().size().GetCheckedArea());
 
   if (!updated && !invalidation->Intersects(recorded_viewport_))
@@ skipping 90 matching lines @@
 }
 
 void DisplayListRecordingSource::Clear() {
   recorded_viewport_ = gfx::Rect();
   display_list_ = nullptr;
   painter_reported_memory_usage_ = 0;
   is_solid_color_ = false;
 }
 
 }  // namespace cc