Ensure Surface size always matches window size on swap

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/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 31 matching lines @@
 
 Display::~Display() {
   manager_->RemoveObserver(this);
 }
 
 bool Display::Initialize(scoped_ptr<OutputSurface> output_surface) {
   output_surface_ = output_surface.Pass();
   return output_surface_->BindToClient(this);
 }
 
-void Display::Resize(SurfaceId id,
-                     const gfx::Size& size,
-                     float device_scale_factor) {
+void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
   current_surface_id_ = id;
+  device_scale_factor_ = device_scale_factor;
+  client_->DisplayDamaged();
+}
+
+void Display::Resize(const gfx::Size& size) {
+  if (size == current_surface_size_)
+    return;
+  if (renderer_)
+    renderer_->Finish();

[jamesr, 2014/12/02 00:04:17]

add a comment here indicating why we need to finish()

we only really need to do this on windows, right? could we make this
configurable so we don't pay this cost on other platforms?

   current_surface_size_ = size;
-  device_scale_factor_ = device_scale_factor;
   client_->DisplayDamaged();
 }
 
 void Display::InitializeRenderer() {
   if (resource_provider_)
     return;
 
   scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
       output_surface_.get(), bitmap_manager_, gpu_memory_buffer_manager_,
       blocking_main_thread_task_runner_.get(), settings_.highp_threshold_min,
@@ skipping 37 matching lines @@
   // while Aggregate is called to immediately run release callbacks afterward.
   scoped_ptr<CompositorFrame> frame =
       aggregator_->Aggregate(current_surface_id_);
   if (!frame)
     return false;
 
   TRACE_EVENT0("cc", "Display::Draw");
   benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
   DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 
+  gfx::Size surface_size;
+  if (!frame_data->render_pass_list.empty())

[jamesr, 2014/12/02 00:04:17]

hmm, maybe Aggregate() should return a null frame if it ended up with an empty
pass list

+    surface_size = frame_data->render_pass_list.back()->output_rect.size();
+
   gfx::Rect device_viewport_rect = gfx::Rect(current_surface_size_);
   gfx::Rect device_clip_rect = device_viewport_rect;
   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);
-  renderer_->SwapBuffers(frame->metadata);
+
+  if (surface_size == current_surface_size_) {
+    renderer_->SwapBuffers(frame->metadata);
+  } else {
+    DidSwapBuffers();
+    DidSwapBuffersComplete();

[piman, 2014/12/01 23:42:09]

Do we need to respect order wrt surface callbacks below?

+  }
+
   for (SurfaceAggregator::SurfaceIndexMap::iterator it =
            aggregator_->previous_contained_surfaces().begin();
        it != aggregator_->previous_contained_surfaces().end();
        ++it) {
     Surface* surface = manager_->GetSurfaceForId(it->first);
     if (surface)
       surface->RunDrawCallbacks();

[jamesr, 2014/12/02 00:04:17]

we probably don't want to run these if we didn't actually draw, right?

   }
   return true;
 }
 
 void Display::DidSwapBuffers() {
   client_->DidSwapBuffers();
 }
 
 void Display::DidSwapBuffersComplete() {
   client_->DidSwapBuffersComplete();
@@ skipping 17 matching lines @@
   return current_surface_id_;
 }
 
 int Display::GetMaxFramesPending() {
   if (!output_surface_)
     return OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
   return output_surface_->capabilities().max_frames_pending;
 }
 
 }  // namespace cc