android: Use UIResource for overscroll glow

content/browser/android/system_ui_resource_manager_impl_unittest.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/resources/ui_resource_bitmap.h"
+#include "content/browser/android/system_ui_resource_manager_impl.h"
+#include "content/public/browser/android/ui_resource_client_android.h"
+#include "content/public/browser/android/ui_resource_provider.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "ui/base/android/system_ui_resource_layer.h"
+
+namespace content {
+
+class TestSystemUIResourceManagerImpl
+    : public content::SystemUIResourceManagerImpl {
+ public:
+  TestSystemUIResourceManagerImpl(content::UIResourceProvider* provider)
+      : SystemUIResourceManagerImpl(provider) {}
+
+  ~TestSystemUIResourceManagerImpl() {}
+
+  virtual void BuildResource(ui::SystemUIResourceManager::Type type) {}
+
+  void SetResourceAsLoaded(ui::SystemUIResourceManager::Type type) {
+    SkBitmap small_bitmap;
+    SkCanvas canvas(small_bitmap);
+    small_bitmap.allocPixels(
+        SkImageInfo::Make(1, 1, kRGBA_8888_SkColorType, kOpaque_SkAlphaType));
+    canvas.drawColor(SK_ColorWHITE);
+    small_bitmap.setImmutable();
+    OnFinishedLoadBitmap(type, &small_bitmap);
+  }
+};
+
+namespace {
+
+const ui::SystemUIResourceManager::Type TEST_RESOURCE_TYPE =
+    ui::SystemUIResourceManager::OVERSCROLL_GLOW;
+
+class MockUIResourceProvider : public content::UIResourceProvider {
+ public:
+  MockUIResourceProvider()
+      : next_ui_resource_id_(0), system_ui_resource_manager_(this) {}
+
+  virtual cc::UIResourceId CreateUIResource(
+      content::UIResourceClientAndroid* client) OVERRIDE {
+    cc::UIResourceId id = next_ui_resource_id_++;
+    client->GetBitmap(id, false);
+    ui_resource_client_map_[id] = client;
+    return id;
+  }
+
+  virtual void DeleteUIResource(cc::UIResourceId id) OVERRIDE {
+    ui_resource_client_map_.erase(id);
+  }
+
+  void LayerTreeHostCleared() {
+    UIResourceClientMap client_map = ui_resource_client_map_;
+    ui_resource_client_map_.clear();
+    for (UIResourceClientMap::iterator iter = client_map.begin();
+         iter != client_map.end();
+         iter++) {
+      iter->second->UIResourceIsInvalid();
+    }
+  }
+
+  void LayerTreeHostReturned() {
+    system_ui_resource_manager_.RefreshResources();
+  }
+
+  TestSystemUIResourceManagerImpl& GetSystemUIResourceManager() {
+    return system_ui_resource_manager_;
+  }
+
+ private:
+  typedef base::hash_map<cc::UIResourceId, content::UIResourceClientAndroid*>
+      UIResourceClientMap;
+
+  cc::UIResourceId next_ui_resource_id_;
+  UIResourceClientMap ui_resource_client_map_;
+
+  // The UIResourceProvider owns the SystemUIResourceManager.
+  TestSystemUIResourceManagerImpl system_ui_resource_manager_;
+};
+
+class MockSystemUIResourceLayer : public ui::SystemUIResourceLayer {
+ public:
+  static scoped_ptr<MockSystemUIResourceLayer> Create() {
+    return make_scoped_ptr(new MockSystemUIResourceLayer());
+  }
+
+  ~MockSystemUIResourceLayer() {}
+
+  virtual void SetUIResourceId(cc::UIResourceId id) { id_ = id; }
+
+  cc::UIResourceId id() { return id_; }
+
+ private:
+  MockSystemUIResourceLayer() : id_(0) {}
+
+  cc::UIResourceId id_;
+};
+
+}  // namespace
+
+class SystemUIResourceManagerImplTest : public testing::Test {
+ public:
+  void Subscribe(ui::SystemUIResourceManager::Type type,
+                 ui::SystemUIResourceLayer* layer) {
+    ui_resource_provider_.GetSystemUIResourceManager().Subscribe(type, layer);
+  }
+
+  void Unsubscribe(ui::SystemUIResourceManager::Type type,
+                   ui::SystemUIResourceLayer* layer) {
+    ui_resource_provider_.GetSystemUIResourceManager().Unsubscribe(type, layer);
+  }
+
+  void LayerTreeHostCleared() { ui_resource_provider_.LayerTreeHostCleared(); }
+
+  void LayerTreeHostReturned() {
+    ui_resource_provider_.LayerTreeHostReturned();
+  }
+
+  void SetResourceAsLoaded(ui::SystemUIResourceManager::Type type) {
+    ui_resource_provider_.GetSystemUIResourceManager().SetResourceAsLoaded(
+        type);
+  }
+
+ private:
+  MockUIResourceProvider ui_resource_provider_;
+};
+
+TEST_F(SystemUIResourceManagerImplTest, SubscribeAfterBitmapLoaded) {
+  scoped_ptr<MockSystemUIResourceLayer> layer =
+      MockSystemUIResourceLayer::Create();
+
+  SetResourceAsLoaded(TEST_RESOURCE_TYPE);
+  EXPECT_EQ(0u, layer->id());
+
+  Subscribe(TEST_RESOURCE_TYPE, layer.get());
+  EXPECT_NE(0u, layer->id());
+}
+
+TEST_F(SystemUIResourceManagerImplTest, SubscribeBeforeLoadBitmap) {
+  scoped_ptr<MockSystemUIResourceLayer> layer =
+      MockSystemUIResourceLayer::Create();
+
+  EXPECT_EQ(0u, layer->id());
+  Subscribe(TEST_RESOURCE_TYPE, layer.get());
+  EXPECT_EQ(0u, layer->id());
+
+  SetResourceAsLoaded(TEST_RESOURCE_TYPE);
+  EXPECT_NE(0u, layer->id());
+}
+
+TEST_F(SystemUIResourceManagerImplTest, ResetLayerTreeHost) {
+  scoped_ptr<MockSystemUIResourceLayer> layer =
+      MockSystemUIResourceLayer::Create();
+
+  SetResourceAsLoaded(TEST_RESOURCE_TYPE);
+  Subscribe(TEST_RESOURCE_TYPE, layer.get());
+  EXPECT_NE(0u, layer->id());
+
+  LayerTreeHostCleared();
+  EXPECT_EQ(0u, layer->id());
+
+  LayerTreeHostReturned();
+  EXPECT_NE(0u, layer->id());
+}
+
+TEST_F(SystemUIResourceManagerImplTest, UnsubscribeLayer) {
+  scoped_ptr<MockSystemUIResourceLayer> layer_a =
+      MockSystemUIResourceLayer::Create();
+
+  scoped_ptr<MockSystemUIResourceLayer> layer_b =
+      MockSystemUIResourceLayer::Create();
+
+  SetResourceAsLoaded(TEST_RESOURCE_TYPE);
+
+  Subscribe(TEST_RESOURCE_TYPE, layer_a.get());
+  Subscribe(TEST_RESOURCE_TYPE, layer_b.get());
+
+  EXPECT_NE(0u, layer_a->id());
+  EXPECT_EQ(layer_a->id(), layer_b->id());
+
+  Unsubscribe(TEST_RESOURCE_TYPE, layer_a.get());
+  EXPECT_EQ(0u, layer_a->id());
+  EXPECT_NE(0u, layer_b->id());
+
+  LayerTreeHostCleared();
+  LayerTreeHostReturned();
+
+  EXPECT_EQ(0u, layer_a->id());
+  EXPECT_NE(0u, layer_b->id());
+}
+
+}  // namespace content