Update from chromium https://crrev.com/302282

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 11 matching lines @@
 namespace cc {
 
 Display::Display(DisplayClient* client,
                  SurfaceManager* manager,
                  SharedBitmapManager* bitmap_manager,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : client_(client),
       manager_(manager),
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+      device_scale_factor_(1.f),
       blocking_main_thread_task_runner_(
           BlockingTaskRunner::Create(base::MessageLoopProxy::current())),
       texture_mailbox_deleter_(
           new TextureMailboxDeleter(base::MessageLoopProxy::current())) {
   manager_->AddObserver(this);
 }
 
 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) {
+void Display::Resize(SurfaceId id,
+                     const gfx::Size& size,
+                     float device_scale_factor) {
   current_surface_id_ = id;
   current_surface_size_ = size;
+  device_scale_factor_ = device_scale_factor;
   client_->DisplayDamaged();
 }
 
 void Display::InitializeRenderer() {
   if (resource_provider_)
     return;
 
   int highp_threshold_min = 0;
   bool use_rgba_4444_texture_format = false;
   size_t id_allocation_chunk_size = 1;
@@ skipping 47 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();
 
-  // Only reshape when we know we are going to draw. Otherwise, the reshape
-  // can leave the window at the wrong size if we never draw and the proper
-  // viewport size is never set.
-  output_surface_->Reshape(current_surface_size_, 1.f);
-  float device_scale_factor = 1.0f;
   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_scale_factor_,
                        device_viewport_rect,
                        device_clip_rect,
                        disable_picture_quad_image_filtering);
   renderer_->SwapBuffers(frame->metadata);
   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)
@@ skipping 28 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