ui/wm/core/shadow_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/wm/core/shadow.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/path_service.h"
   9 #include "third_party/skia/include/core/SkBitmap.h"
  10 #include "ui/aura/test/aura_test_base.h"
  11 #include "ui/aura/test/test_windows.h"
  12 #include "ui/aura/window.h"
  13 #include "ui/base/resource/resource_bundle.h"
  14 #include "ui/base/ui_base_paths.h"
  15 #include "ui/compositor/layer.h"
  16 #include "ui/compositor/layer_tree_owner.h"
  17 #include "ui/resources/grit/ui_resources.h"
  18
  19 namespace wm {
  20
  21 namespace {
  22
  23 const int kSmallBitmapSize = 129;
  24 const int kLargeBitmapSize = 269;
  25
  26 // Mock for the ResourceBundle::Delegate class.
  27 class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
  28  public:
  29   MockResourceBundleDelegate() : last_resource_id_(0) {
  30     SkBitmap bitmap_small, bitmap_large;
  31     bitmap_small.allocPixels(
  32         SkImageInfo::MakeN32Premul(kSmallBitmapSize, kSmallBitmapSize));
  33     bitmap_large.allocPixels(
  34         SkImageInfo::MakeN32Premul(kLargeBitmapSize, kLargeBitmapSize));
  35     image_small_ = gfx::Image::CreateFrom1xBitmap(bitmap_small);
  36     image_large_ = gfx::Image::CreateFrom1xBitmap(bitmap_large);
  37   }
  38   ~MockResourceBundleDelegate() override {}
  39
  40   // ResourceBundle::Delegate:
  41   base::FilePath GetPathForResourcePack(const base::FilePath& pack_path,
  42                                         ui::ScaleFactor scale_factor) override {
  43     return base::FilePath();
  44   }
  45   base::FilePath GetPathForLocalePack(const base::FilePath& pack_path,
  46                                       const std::string& locale) override {
  47     return base::FilePath();
  48   }
  49   gfx::Image GetImageNamed(int resource_id) override {
  50     last_resource_id_ = resource_id;
  51     switch (resource_id) {
  52       case IDR_WINDOW_BUBBLE_SHADOW_SMALL:
  53         return image_small_;
  54       case IDR_AURA_SHADOW_ACTIVE:
  55       case IDR_AURA_SHADOW_INACTIVE:
  56         return image_large_;
  57       default:
  58         NOTREACHED();
  59         return gfx::Image();
  60     }
  61   }
  62   gfx::Image GetNativeImageNamed(int resource_id,
  63                                  ui::ResourceBundle::ImageRTL rtl) override {
  64     return gfx::Image();
  65   }
  66   base::RefCountedStaticMemory* LoadDataResourceBytes(
  67       int resource_id,
  68       ui::ScaleFactor scale_factor) override {
  69     return NULL;
  70   }
  71   bool GetRawDataResource(int resource_id,
  72                           ui::ScaleFactor scale_factor,
  73                           base::StringPiece* value) override {
  74     return false;
  75   }
  76   bool GetLocalizedString(int message_id, base::string16* value) override {
  77     return false;
  78   }
  79   scoped_ptr<gfx::Font> GetFont(ui::ResourceBundle::FontStyle style) override {
  80     return nullptr;
  81   }
  82
  83   int last_resource_id() const { return last_resource_id_; }
  84
  85  private:
  86   gfx::Image image_small_;
  87   gfx::Image image_large_;
  88   int last_resource_id_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(MockResourceBundleDelegate);
  91 };
  92
  93 }  // namespace
  94
  95 class ShadowTest: public aura::test::AuraTestBase {
  96  public:
  97   ShadowTest() {}
  98   ~ShadowTest() override {}
  99
 100   MockResourceBundleDelegate* delegate() { return delegate_.get(); }
 101
 102   // aura::testAuraBase:
 103   void SetUp() override {
 104     aura::test::AuraTestBase::SetUp();
 105     delegate_.reset(new MockResourceBundleDelegate());
 106     if (ResourceBundle::HasSharedInstance())
 107       ui::ResourceBundle::CleanupSharedInstance();
 108     ui::ResourceBundle::InitSharedInstanceWithLocale(
 109         "en-US", delegate(), ui::ResourceBundle::LOAD_COMMON_RESOURCES);
 110   }
 111   void TearDown() override {
 112     ui::ResourceBundle::CleanupSharedInstance();
 113     base::FilePath ui_test_pak_path;
 114     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
 115     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
 116     aura::test::AuraTestBase::TearDown();
 117   }
 118  private:
 119   scoped_ptr<MockResourceBundleDelegate> delegate_;
 120   DISALLOW_COPY_AND_ASSIGN(ShadowTest);
 121 };
 122
 123 // Test if the proper image is set for the specified style.
 124 TEST_F(ShadowTest, UpdateImagesForStyle) {
 125   Shadow shadow;
 126
 127   shadow.Init(Shadow::STYLE_SMALL);
 128   EXPECT_EQ(delegate()->last_resource_id(), IDR_WINDOW_BUBBLE_SHADOW_SMALL);
 129   shadow.SetStyle(Shadow::STYLE_ACTIVE);
 130   EXPECT_EQ(delegate()->last_resource_id(), IDR_AURA_SHADOW_ACTIVE);
 131   shadow.SetStyle(Shadow::STYLE_INACTIVE);
 132   EXPECT_EQ(delegate()->last_resource_id(), IDR_AURA_SHADOW_INACTIVE);
 133 }
 134
 135 // Test if the proper content bounds is calculated based on the current style.
 136 TEST_F(ShadowTest, SetContentBounds) {
 137   Shadow shadow;
 138
 139   // Verify that layer bounds are inset from content bounds.
 140   shadow.Init(Shadow::STYLE_ACTIVE);
 141   gfx::Rect content_bounds(100, 100, 300, 300);
 142   shadow.SetContentBounds(content_bounds);
 143   EXPECT_EQ(shadow.content_bounds(), content_bounds);
 144   EXPECT_EQ(shadow.layer()->bounds(), gfx::Rect(36, 36, 428, 428));
 145
 146   shadow.SetStyle(Shadow::STYLE_SMALL);
 147   EXPECT_EQ(shadow.content_bounds(), content_bounds);
 148   EXPECT_EQ(shadow.layer()->bounds(), gfx::Rect(96, 96, 308, 308));
 149 }
 150 }  // namespace wm