Change ui::wm::Shadow to pass ImageSkia instead of SkBitmap.

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 13 matching lines @@
 #include "cc/output/delegated_frame_data.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "cc/resources/transferable_resource.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace {
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
   while (layer->parent())
     layer = layer->parent();
@@ skipping 26 matching lines @@
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      nine_patch_layer_bitmap_scale_factor_(1.0f) {

[oshima, 2015/03/14 05:42:55]

Why you need this? You should just use device_scale_factor_

[hshi1, 2015/03/16 16:50:48]

Done.

   CreateCcLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(false),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      nine_patch_layer_bitmap_scale_factor_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   if (animator_.get())
     animator_->SetDelegate(NULL);
   animator_ = NULL;
@@ skipping 498 matching lines @@
   solid_color_layer_ = new_layer;
 
   mailbox_ = cc::TextureMailbox();
   if (mailbox_release_callback_) {
     mailbox_release_callback_->Run(0, false);
     mailbox_release_callback_.reset();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
-void Layer::UpdateNinePatchLayerBitmap(const SkBitmap& bitmap) {
+void Layer::UpdateNinePatchLayerImage(const gfx::ImageSkia& image) {
   DCHECK(type_ == LAYER_NINE_PATCH && nine_patch_layer_.get());
+  nine_patch_layer_bitmap_scale_factor_ = device_scale_factor_;
+  SkBitmap bitmap = image.GetRepresentation(
+      nine_patch_layer_bitmap_scale_factor_).sk_bitmap();
   SkBitmap bitmap_copy;
   if (bitmap.isImmutable()) {
     bitmap_copy = bitmap;
   } else {
     // UIResourceBitmap requires an immutable copy of the input |bitmap|.
     bitmap.copyTo(&bitmap_copy);
     bitmap_copy.setImmutable();
   }
   nine_patch_layer_->SetBitmap(bitmap_copy);
 }
 
 void Layer::UpdateNinePatchLayerAperture(const gfx::Rect& aperture) {
   DCHECK(type_ == LAYER_NINE_PATCH && nine_patch_layer_.get());
-  nine_patch_layer_->SetAperture(aperture);
+  gfx::Rect aperture_in_pixel =
+      gfx::ConvertRectToPixel(nine_patch_layer_bitmap_scale_factor_, aperture);
+  nine_patch_layer_->SetAperture(aperture_in_pixel);
 }
 
 void Layer::UpdateNinePatchLayerBorder(const gfx::Rect& border) {
   DCHECK(type_ == LAYER_NINE_PATCH && nine_patch_layer_.get());
   nine_patch_layer_->SetBorder(border);
 }
 
 void Layer::SetColor(SkColor color) { GetAnimator()->SetColor(color); }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
@@ skipping 50 matching lines @@
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
 }
 
 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
   if (animator_.get())
     animator_->StopAnimatingProperty(LayerAnimationElement::TRANSFORM);
   device_scale_factor_ = device_scale_factor;

[oshima, 2015/03/14 05:42:55]

you need to update the image here.

[hshi1, 2015/03/16 16:50:47]

Done.

   RecomputeDrawsContentAndUVRect();
   RecomputePosition();
   SchedulePaint(gfx::Rect(bounds_.size()));
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
   if (layer_mask_)
     layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
@@ skipping 351 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui