[Android] Implementation of overscroll effect for Android L

content/browser/android/system_ui_resource_manager_impl.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 "content/browser/android/system_ui_resource_manager_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/observer_list.h"
 #include "base/threading/worker_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "content/public/browser/android/ui_resource_client_android.h"
 #include "content/public/browser/android/ui_resource_provider.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/effects/SkPorterDuff.h"
 #include "ui/gfx/android/java_bitmap.h"
+#include "ui/gfx/screen.h"
 
 namespace content {
+namespace {
+
+SkBitmap CreateOverscrollGlowLBitmap(const gfx::Size& screen_size) {
+  // TODO(jdduke): Fetch the theme color from the platform using
+  // the com.android.internal.R.styleable.EdgeEffect attribute and the
+  // com.android.internal.R.styleable.EdgeEffect_colorPrimary color key.
+  const int kThemeColor = 0xff666666;
+  const float kSin = 0.5f;    // sin(PI / 6)
+  const float kCos = 0.866f;  // cos(PI / 6);
+
+  SkPaint paint;
+  paint.setAntiAlias(true);
+  paint.setColor((kThemeColor & 0xffffff) | 0x33000000);

[aelias_OOO_until_Jul13, 2014/08/14 22:54:20]

Let's just do paint.setAlpha(0x33).  We shouldn't leave dead code lying around
until we're ready to support theming as currently it's potentially confusing.

[jdduke (slow), 2014/08/15 19:15:06]

Done.

+  paint.setStyle(SkPaint::kFill_Style);
+
+  const float screen_width =

[aelias_OOO_until_Jul13, 2014/08/14 22:54:20]

"screen_width" sometimes being height seems confusing, I suggest getting rid of
this temporary and merging this into the arc_width line.

[jdduke (slow), 2014/08/15 19:15:06]

Done.

+      std::min(screen_size.width(), screen_size.height());
+  const float arc_width = screen_width * 0.5f / kSin;
+  const float y = kCos * arc_width;
+  const float height = arc_width - y;
+  gfx::Size bounds(arc_width, height);

[aelias_OOO_until_Jul13, 2014/08/14 22:54:20]

If I'm reading this correctly, this still ends up rather large even with A8,
right?  Like 500Kb on a phone?  Can we shrink the size further and make a
tradeoff about sharpness?

[jdduke (slow), 2014/08/15 19:15:06]

Where are you getting 500KB? On a 720 phone, we end up with 720x97x1=70KB, and
on a 1080 phone, 1080x145x1=156KB. That's larger than I'd like, but at least now
we're sharing the resource across all edges, and each edge only uses the
resource once.

I tried 0.25 instead of 0.5f in the width multiplier (the current multiplier,
0.5 / kSin is just 1, I wonder if we should just get rid of that multiplication
for simplicity), the artifacts become a good deal more apparent.  I guess I
could go down to 0.4f or something like that?

+  SkRect arc_rect = SkRect::MakeXYWH(
+      -arc_width / 2.f, -arc_width - y, arc_width * 2.f, arc_width * 2.f);
+  SkBitmap glow_bitmap;
+  if (!glow_bitmap.allocPixels(
+          SkImageInfo::MakeA8(bounds.width(), bounds.height()))) {
+    LOG(FATAL) << " Failed to allocate bitmap of size " << bounds.width() << "x"
+               << bounds.height();
+  }
+
+  SkCanvas canvas(glow_bitmap);
+  canvas.clipRect(SkRect::MakeXYWH(0, 0, bounds.width(), bounds.height()));
+  canvas.drawArc(arc_rect, 45, 90, true, paint);
+  return glow_bitmap;
+}
+
+void LoadBitmap(ui::SystemUIResourceManager::ResourceType type,
+                SkBitmap* bitmap_holder,
+                const gfx::Size& screen_size) {
+  TRACE_EVENT1(
+      "browser", "SystemUIResourceManagerImpl::LoadBitmap", "type", type);
+  SkBitmap bitmap;
+  switch (type) {
+    case ui::SystemUIResourceManager::OVERSCROLL_EDGE:
+      bitmap = gfx::CreateSkBitmapFromAndroidResource(
+          "android:drawable/overscroll_edge", gfx::Size(128, 12));
+      break;
+    case ui::SystemUIResourceManager::OVERSCROLL_GLOW:
+      bitmap = gfx::CreateSkBitmapFromAndroidResource(
+          "android:drawable/overscroll_glow", gfx::Size(128, 64));
+      break;
+    case ui::SystemUIResourceManager::OVERSCROLL_GLOW_L:
+      bitmap = CreateOverscrollGlowLBitmap(screen_size);
+      break;
+  }
+  bitmap.setImmutable();
+  *bitmap_holder = bitmap;
+}
+
+}  // namespace
 
 class SystemUIResourceManagerImpl::Entry
     : public content::UIResourceClientAndroid {
  public:
   explicit Entry(UIResourceProvider* provider) : id_(0), provider_(provider) {
     DCHECK(provider);
   }
 
   virtual ~Entry() {
     if (id_)
       provider_->DeleteUIResource(id_);
     id_ = 0;
   }
 
   void SetBitmap(const SkBitmap& bitmap) {
-    // TODO(jdduke): Verify validity of |bitmap| after resolving resource
-    // loading issues on Android L, crbug.com/389744.
+    DCHECK(!bitmap.empty());
     DCHECK(bitmap_.empty());
     DCHECK(!id_);
     bitmap_ = bitmap;
   }
 
   cc::UIResourceId GetUIResourceId() {
     if (bitmap_.empty())
       return 0;
     if (!id_)
       id_ = provider_->CreateUIResource(this);
@@ skipping 47 matching lines @@
     BuildResource(type);
   }
   return resource_map_[type].get();
 }
 
 void SystemUIResourceManagerImpl::BuildResource(ResourceType type) {
   DCHECK(GetEntry(type)->bitmap().empty());
 
   // Instead of blocking the main thread, we post a task to load the bitmap.
   SkBitmap* bitmap = new SkBitmap();
+  gfx::Size screen_size =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().GetSizeInPixel();
   base::Closure load_bitmap =
-      base::Bind(&SystemUIResourceManagerImpl::LoadBitmap, type, bitmap);
+      base::Bind(&LoadBitmap, type, bitmap, screen_size);
   base::Closure finished_load =
       base::Bind(&SystemUIResourceManagerImpl::OnFinishedLoadBitmap,
                  weak_factory_.GetWeakPtr(),
                  type,
                  base::Owned(bitmap));
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE, load_bitmap, finished_load, true);
 }
 
-void SystemUIResourceManagerImpl::LoadBitmap(ResourceType type,
-                                             SkBitmap* bitmap_holder) {
-  SkBitmap bitmap;
-  switch (type) {
-    case ui::SystemUIResourceManager::OVERSCROLL_EDGE:
-      bitmap = gfx::CreateSkBitmapFromAndroidResource(
-          "android:drawable/overscroll_edge", gfx::Size(128, 12));
-      break;
-    case ui::SystemUIResourceManager::OVERSCROLL_GLOW:
-      bitmap = gfx::CreateSkBitmapFromAndroidResource(
-          "android:drawable/overscroll_glow", gfx::Size(128, 64));
-      break;
-  }
-  bitmap.setImmutable();
-  *bitmap_holder = bitmap;
-}
-
 void SystemUIResourceManagerImpl::OnFinishedLoadBitmap(
     ResourceType type,
     SkBitmap* bitmap_holder) {
   DCHECK(bitmap_holder);
   GetEntry(type)->SetBitmap(*bitmap_holder);
 }
 
 }  // namespace content