Make exo::Surface set device_scale_factor.

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 <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 90 matching lines @@
     return HTNOWHERE;
   }
   bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) override {
     return true;
   }
   bool CanFocus() override { return true; }
   void OnCaptureLost() override {}
   void OnPaint(const ui::PaintContext& context) override {}
-  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {
+    surface_->SetDeviceScaleFactor(device_scale_factor);
+  }
   void OnWindowDestroying(aura::Window* window) override {}
   void OnWindowDestroyed(aura::Window* window) override { delete this; }
   void OnWindowTargetVisibilityChanged(bool visible) override {}
   bool HasHitTestMask() const override { return surface_->HasHitTestMask(); }
   void GetHitTestMask(gfx::Path* mask) const override {
     surface_->GetHitTestMask(mask);
   }
   void OnKeyEvent(ui::KeyEvent* event) override {
     // Propagates the key event upto the top-level views Widget so that we can
     // trigger proper events in the views/ash level there. Event handling for
@@ skipping 276 matching lines @@
 
   pending_state_.blend_mode = blend_mode;
 }
 
 void Surface::SetAlpha(float alpha) {
   TRACE_EVENT1("exo", "Surface::SetAlpha", "alpha", alpha);
 
   pending_state_.alpha = alpha;
 }
 
+void Surface::SetDeviceScaleFactor(float device_scale_factor) {
+  device_scale_factor_ = device_scale_factor;
+}
+
 void Surface::Commit() {
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
   if (state_ != pending_state_)
     has_pending_layer_changes_ = true;
 
   if (has_pending_contents_) {
     if (pending_buffer_.buffer()) {
@@ skipping 422 matching lines @@
   cc::CompositorFrame frame;
   // If we commit while we don't have an active BeginFrame, we acknowledge a
   // manual one.
   if (current_begin_frame_ack_.sequence_number ==
       cc::BeginFrameArgs::kInvalidFrameNumber) {
     current_begin_frame_ack_ = cc::BeginFrameAck::CreateManualAckWithDamage();
   } else {
     current_begin_frame_ack_.has_damage = true;
   }
   frame.metadata.begin_frame_ack = current_begin_frame_ack_;
+  frame.metadata.device_scale_factor = device_scale_factor_;
 
   if (current_resource_.id) {
     // Texture quad is only needed if buffer is not fully transparent.
     if (state_.alpha) {
       cc::TextureDrawQuad* texture_quad =
           render_pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
       float vertex_opacity[4] = {1.0, 1.0, 1.0, 1.0};
       gfx::Rect opaque_rect;
       if (!current_resource_has_alpha_ ||
           state_.blend_mode == SkBlendMode::kSrc ||
@@ skipping 16 matching lines @@
         render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
     solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK, false);
   }
 
   frame.render_pass_list.push_back(std::move(render_pass));
   compositor_frame_sink_holder_->GetCompositorFrameSink()
       ->SubmitCompositorFrame(local_surface_id_, std::move(frame));
 }
 
 }  // namespace exo