exo: Add Surface::SetBufferScale.

components/exo/surface.cc

 // Copyright 2015 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 "components/exo/surface.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/resources/single_release_callback.h"
 #include "components/exo/buffer.h"
 #include "components/exo/surface_delegate.h"
 #include "components/exo/surface_observer.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gfx/transform_util.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(exo::Surface*);
 
 namespace exo {
 namespace {
 
 // A property key containing the surface that is associated with
 // window. If unset, no surface is associated with window.
 DEFINE_WINDOW_PROPERTY_KEY(Surface*, kSurfaceKey, nullptr);
 
@@ skipping 51 matching lines @@
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : aura::Window(new EmptyWindowDelegate),
       has_pending_contents_(false),
+      pending_buffer_scale_(1.0f),
       needs_commit_surface_hierarchy_(false),
       update_contents_after_successful_compositing_(false),
       compositor_(nullptr),
       delegate_(nullptr) {
   SetType(ui::wm::WINDOW_TYPE_CONTROL);
   SetName("ExoSurface");
   Init(ui::LAYER_SOLID_COLOR);
   SetProperty(kSurfaceKey, this);
   set_owned_by_parent(false);
 }
@@ skipping 39 matching lines @@
   pending_frame_callbacks_.push_back(callback);
 }
 
 void Surface::SetOpaqueRegion(const SkRegion& region) {
   TRACE_EVENT1("exo", "Surface::SetOpaqueRegion", "region",
                gfx::SkIRectToRect(region.getBounds()).ToString());
 
   pending_opaque_region_ = region;
 }
 
+void Surface::SetBufferScale(float scale) {
+  TRACE_EVENT1("exo", "Surface::SetBufferScale", "scale", scale);
+
+  pending_buffer_scale_ = scale;
+}
+
 void Surface::AddSubSurface(Surface* sub_surface) {
   TRACE_EVENT1("exo", "Surface::AddSubSurface", "sub_surface",
                sub_surface->AsTracedValue());
 
   DCHECK(!sub_surface->parent());
   DCHECK(!sub_surface->IsVisible());
   DCHECK(sub_surface->bounds().origin() == gfx::Point());
   AddChild(sub_surface);
 
   DCHECK(!ListContainsEntry(pending_sub_surfaces_, sub_surface));
@@ skipping 102 matching lines @@
       texture_mailbox_release_callback =
           current_buffer_->ProduceTextureMailbox(&texture_mailbox);
     }
 
     if (texture_mailbox_release_callback) {
       // Update layer with the new contents.
       layer()->SetTextureMailbox(texture_mailbox,
                                  texture_mailbox_release_callback.Pass(),
                                  texture_mailbox.size_in_pixels());
       layer()->SetTextureFlipped(false);
-      layer()->SetBounds(gfx::Rect(layer()->bounds().origin(),
-                                   texture_mailbox.size_in_pixels()));
+      gfx::Size contents_size(gfx::ScaleToFlooredSize(
+          texture_mailbox.size_in_pixels(), 1.0f / pending_buffer_scale_));
+      layer()->SetBounds(gfx::Rect(layer()->bounds().origin(), contents_size));
       layer()->SetFillsBoundsOpaquely(pending_opaque_region_.contains(
-          gfx::RectToSkIRect(gfx::Rect(texture_mailbox.size_in_pixels()))));
+          gfx::RectToSkIRect(gfx::Rect(contents_size))));
+      layer()->SetTransform(gfx::GetScaleTransform(
+          gfx::Rect(texture_mailbox.size_in_pixels()).CenterPoint(),
+          1.0f / pending_buffer_scale_));

[lpique, 2016/01/04 19:36:20]

The call to ScaleToFlooredSize() includes (as the name indicates) flooring to an
integer value.

Shouldn't this set a scale transform of "contents_size /
texture_mailbox.size_in_pixels()" so that the adjusted size is used to set the
scale?

[reveman, 2016/01/05 09:02:48]

Good point. Done.

     } else {
       // Show solid color content if no buffer is attached or we failed
       // to produce a texture mailbox for the currently attached buffer.
       layer()->SetShowSolidColorContent();
       layer()->SetColor(SK_ColorBLACK);
     }
 
     // Schedule redraw of the damage region.
     layer()->SchedulePaint(pending_damage_);
     pending_damage_ = gfx::Rect();
@@ skipping 36 matching lines @@
     // Stack next sub-surface above this sub-surface.
     stacking_target = sub_surface;
 
     // Update sub-surface position relative to surface origin.
     sub_surface->SetBounds(
         gfx::Rect(sub_surface_entry.second, sub_surface->layer()->size()));
   }
 }
 
 gfx::Size Surface::GetPreferredSize() const {
-  return pending_buffer_ ? pending_buffer_->GetSize() : layer()->size();
+  return pending_buffer_ ? gfx::ScaleToFlooredSize(pending_buffer_->GetSize(),
+                                                   1.0f / pending_buffer_scale_)
+                         : layer()->size();
 }
 
 bool Surface::IsSynchronized() const {
   return delegate_ ? delegate_->IsSurfaceSynchronized() : false;
 }
 
 void Surface::SetSurfaceDelegate(SurfaceDelegate* delegate) {
   DCHECK(!delegate_ || !delegate);
   delegate_ = delegate;
 }
@@ skipping 69 matching lines @@
   // of the surface next time the compositor successfully ends compositing.
   update_contents_after_successful_compositing_ = true;
 }
 
 void Surface::OnCompositingShuttingDown(ui::Compositor* compositor) {
   compositor->RemoveObserver(this);
   compositor_ = nullptr;
 }
 
 }  // namespace exo