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"
@@ skipping 92 matching lines @@
 
   return false;
 }
 
 bool DisplayListRecordingSource::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
-    RecordingMode recording_mode) {
+    RecordingMode recording_mode,
+    bool blink_synchronous_painting_enabled) {
   ScopedDisplayListRecordingSourceUpdateTimer timer;
-  bool updated = false;
 
-  if (size_ != layer_size) {
-    size_ = layer_size;
-    updated = true;
+  if (blink_synchronous_painting_enabled) {
+    recorded_viewport_ = gfx::Rect(layer_size);
+  } else {
+    bool updated = false;
+
+    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()));

[enne (OOO), 2015/11/17 23:44:49]

Because you still need to add invalidations for newly exposed recording areas
below, I think a better API would be to not pass a setting all the way through
and instead add ContentLayerClient::PaintableViewport() or some such.

Then you could ask for the recorded_viewport before you paint, and then go
through this same logic.  And then PaintContents wouldn't need a parameter at
all (in the future).

Alternatively, the synchronous paint path could do all this work?

[chrishtr, 2015/11/18 21:09:40]

Done.

+
+    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.

[enne (OOO), 2015/11/17 23:44:49]

This is still needed even for synchronous painting.

[chrishtr, 2015/11/18 21:09:40]

Done.

+      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);
+
+      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_))
+      return false;
   }
 
-  // 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);
-
-    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_))
-    return false;
-
   ContentLayerClient::PaintingControlSetting painting_control =
       ContentLayerClient::PAINTING_BEHAVIOR_NORMAL;
 
   switch (recording_mode) {
     case RECORD_NORMALLY:
       // Already setup for normal recording.
       break;
     case RECORD_WITH_PAINTING_DISABLED:
       painting_control = ContentLayerClient::DISPLAY_LIST_PAINTING_DISABLED;
       break;
     case RECORD_WITH_CACHING_DISABLED:
       painting_control = ContentLayerClient::DISPLAY_LIST_CACHING_DISABLED;
       break;
     case RECORD_WITH_CONSTRUCTION_DISABLED:
       painting_control = ContentLayerClient::DISPLAY_LIST_CONSTRUCTION_DISABLED;
       break;
     case RECORD_WITH_SK_NULL_CANVAS:
     case RECORDING_MODE_COUNT:
       NOTREACHED();
   }
 
   // TODO(vmpstr): Add a slow_down_recording_scale_factor_for_debug_ to be able
   // to slow down recording.
-  display_list_ =
-      painter->PaintContentsToDisplayList(recorded_viewport_, painting_control);
+  display_list_ = painter->PaintContentsToDisplayList(painting_control,
+                                                      &recorded_viewport_);
   painter_reported_memory_usage_ = painter->GetApproximateUnsharedMemoryUsage();
 
   DetermineIfSolidColor();
   display_list_->EmitTraceSnapshot();
   if (generate_discardable_images_metadata_)
     display_list_->GenerateDiscardableImagesMetadata();
 
   return true;
 }
 
@@ skipping 53 matching lines @@
 }
 
 void DisplayListRecordingSource::Clear() {
   recorded_viewport_ = gfx::Rect();
   display_list_ = nullptr;
   painter_reported_memory_usage_ = 0;
   is_solid_color_ = false;
 }
 
 }  // namespace cc