cc: Make DisplayScheduler aware of resize and add tracing.

cc/surfaces/display.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/surfaces/display.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 44 matching lines @@
                          DisplayScheduler* scheduler) {
   output_surface_ = output_surface.Pass();
   scheduler_ = scheduler;
   return output_surface_->BindToClient(this);
 }
 
 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
   if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
     return;
 
+  TRACE_EVENT0("cc", "Display::SetSurfaceId");
+
   current_surface_id_ = id;
   device_scale_factor_ = device_scale_factor;
 
   UpdateRootSurfaceResourcesLocked();
   if (scheduler_)
-    scheduler_->EntireDisplayDamaged(id);
+    scheduler_->SetNewRootSurface(id);
 }
 
 void Display::Resize(const gfx::Size& size) {
   if (size == current_surface_size_)
     return;
+
+  TRACE_EVENT0("cc", "Display::Resize");
+
   // Need to ensure all pending swaps have executed before the window is
   // resized, or D3D11 will scale the swap output.
   if (settings_.finish_rendering_on_resize) {
     if (!swapped_since_resize_ && scheduler_)
       scheduler_->ForceImmediateSwapIfPossible();
     if (swapped_since_resize_ && output_surface_ &&
         output_surface_->context_provider())
       output_surface_->context_provider()->ContextGL()->ShallowFinishCHROMIUM();
   }
   swapped_since_resize_ = false;
   current_surface_size_ = size;
   if (scheduler_)
-    scheduler_->EntireDisplayDamaged(current_surface_id_);
+    scheduler_->DisplayResized();
 }
 
 void Display::SetExternalClip(const gfx::Rect& clip) {
   external_clip_ = clip;
 }
 
 void Display::InitializeRenderer() {
   if (resource_provider_)
     return;
 
@@ skipping 40 matching lines @@
 }
 
 void Display::UpdateRootSurfaceResourcesLocked() {
   Surface* surface = manager_->GetSurfaceForId(current_surface_id_);
   bool root_surface_resources_locked = !surface || !surface->GetEligibleFrame();
   if (scheduler_)
     scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked);
 }
 
 bool Display::DrawAndSwap() {
-  if (current_surface_id_.is_null())
+  TRACE_EVENT0("cc", "Display::DrawAndSwap");
+
+  if (current_surface_id_.is_null()) {
+    TRACE_EVENT_INSTANT0("cc", "No root surface.", TRACE_EVENT_SCOPE_THREAD);
     return false;
+  }
 
   InitializeRenderer();
-  if (!output_surface_)
+  if (!output_surface_) {
+    TRACE_EVENT_INSTANT0("cc", "No output surface", TRACE_EVENT_SCOPE_THREAD);
     return false;
+  }
 
   if (output_surface_->SurfaceIsSuspendForRecycle())
     return false;
 
   scoped_ptr<CompositorFrame> frame =
       aggregator_->Aggregate(current_surface_id_);
-  if (!frame)
+  if (!frame) {
+    TRACE_EVENT_INSTANT0("cc", "Empty aggregated frame.",
+                         TRACE_EVENT_SCOPE_THREAD);
     return false;
-
-  TRACE_EVENT0("cc", "Display::DrawAndSwap");
+  }
 
   // Run callbacks early to allow pipelining.
   for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
     Surface* surface = manager_->GetSurfaceForId(id_entry.first);
     if (surface)
       surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN);
   }
+
   DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 
   frame->metadata.latency_info.insert(frame->metadata.latency_info.end(),
                                       stored_latency_info_.begin(),
                                       stored_latency_info_.end());
   stored_latency_info_.clear();
   bool have_copy_requests = false;
   for (const auto* pass : frame_data->render_pass_list) {
     have_copy_requests |= !pass->copy_requests.empty();
   }
 
   gfx::Size surface_size;
   bool have_damage = false;
   if (!frame_data->render_pass_list.empty()) {
     surface_size = frame_data->render_pass_list.back()->output_rect.size();
     have_damage =
         !frame_data->render_pass_list.back()->damage_rect.size().IsEmpty();
   }
-  bool avoid_swap = surface_size != current_surface_size_;
+
+  bool size_matches = surface_size == current_surface_size_;
+  if (!size_matches)
+    TRACE_EVENT_INSTANT0("cc", "Size missmatch.", TRACE_EVENT_SCOPE_THREAD);
+
   bool should_draw = !frame->metadata.latency_info.empty() ||
-                     have_copy_requests || (have_damage && !avoid_swap);
+                     have_copy_requests || (have_damage && size_matches);
 
   if (should_draw) {
     gfx::Rect device_viewport_rect = gfx::Rect(current_surface_size_);
     gfx::Rect device_clip_rect =
         external_clip_.IsEmpty() ? device_viewport_rect : external_clip_;
     bool disable_picture_quad_image_filtering = false;
 
     renderer_->DecideRenderPassAllocationsForFrame(
         frame_data->render_pass_list);
     renderer_->DrawFrame(&frame_data->render_pass_list, device_scale_factor_,
                          device_viewport_rect, device_clip_rect,
                          disable_picture_quad_image_filtering);
+  } else {
+    TRACE_EVENT_INSTANT0("cc", "Draw skipped.", TRACE_EVENT_SCOPE_THREAD);
   }
 
-  if (should_draw && !avoid_swap) {
+  bool should_swap = should_draw && size_matches;
+  if (should_swap) {
     swapped_since_resize_ = true;
     for (auto& latency : frame->metadata.latency_info) {
       TRACE_EVENT_FLOW_STEP0(
           "input,benchmark",
           "LatencyInfo.Flow",
           TRACE_ID_DONT_MANGLE(latency.trace_id),
           "Display::DrawAndSwap");
     }
     benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
     renderer_->SwapBuffers(frame->metadata);
   } else {
+    TRACE_EVENT_INSTANT0("cc", "Swap skipped.", TRACE_EVENT_SCOPE_THREAD);
     stored_latency_info_.insert(stored_latency_info_.end(),
                                 frame->metadata.latency_info.begin(),
                                 frame->metadata.latency_info.end());
     DidSwapBuffers();
     DidSwapBuffersComplete();
   }
 
   return true;
 }
 
@@ skipping 69 matching lines @@
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc