android: Use UIResource for overscroll glow

ui/base/android/window_android.h

 // Copyright 2013 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.
 
 #ifndef UI_BASE_ANDROID_WINDOW_ANDROID_H_
 #define UI_BASE_ANDROID_WINDOW_ANDROID_H_
 
 #include <jni.h>
 #include <vector>
 #include "base/android/jni_weak_ref.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
+#include "cc/resources/ui_resource_client.h"
 #include "ui/base/ui_base_export.h"
 #include "ui/gfx/vector2d_f.h"
 
 namespace ui {
 
+class UIResourceClientAndroid;
 class WindowAndroidCompositor;
 class WindowAndroidObserver;
 
 // Android implementation of the activity window.
 class UI_BASE_EXPORT WindowAndroid {
  public:
+  enum SystemUIResource {
+    OVERSCROLL_EDGE,
+    OVERSCROLL_GLOW
+  };
+
   WindowAndroid(JNIEnv* env, jobject obj, jlong vsync_period);
 
   void Destroy(JNIEnv* env, jobject obj);
 
   base::android::ScopedJavaLocalRef<jobject> GetJavaObject();
 
   static bool RegisterWindowAndroid(JNIEnv* env);
 
   // The content offset is used to translate snapshots to the correct part of
   // the window.
@@ skipping 14 matching lines @@
   void AddObserver(WindowAndroidObserver* observer);
   void RemoveObserver(WindowAndroidObserver* observer);
 
   WindowAndroidCompositor* GetCompositor() { return compositor_; }
 
   void RequestVSyncUpdate();
   void SetNeedsAnimate();
   void OnVSync(JNIEnv* env, jobject obj, jlong time_micros);
   void Animate(base::TimeTicks begin_frame_time);
 
+  void InitializeSystemUIResource(SystemUIResource system_resource,

[powei, 2014/07/08 19:12:43]

having this feels a little awkward, but since ui does not depend on cc, we can't
actually upload the bitmaps as ui resource in WindowAndroid.

[jdduke (slow), 2014/07/08 20:10:11]

Hmm, who is responsible for calling this now for the overscroll resources?

[powei, 2014/07/12 00:24:46]

Done. Moved resource loading to system_ui_resource_manager_impl

+                                  scoped_ptr<UIResourceClientAndroid> resource);
+
+  cc::UIResourceId GetSystemUIResource(SystemUIResource system_resource);

[jdduke (slow), 2014/07/08 20:10:11]

Is it worth making this method const?

[jdduke (slow), 2014/07/08 20:42:08]

This pull and push model makes synchronization somewhat hard to follow,
particularly if we scale this to more resources (as I'm planning with the new
composited selection handles).  

I'm wondering if we could have a subscriber model, where instead of polling
|GetSystemUIResource()| and then pushing it to the UIResourceLayer every frame,
or as often as we can to make sure the two are in sync, we subscribe a
UIResourceLayer to a particular SystemUIResource (perhaps storing a weak pointer
to the layer, and then pushing the resource id when it has changed?). 

void SubscribeToSystemUIResource(SystemUIResource system_resource,
UIResourceLayer* layer);
void UnsubscribeFromSystemUIResource(UIResourceLayer*);

I'm not sure if that makes sense in the current architecture, or if that would
be better accomplished at a later time?

[powei, 2014/07/09 20:41:03]

A subscriber model sounds good.  Although it would be different from the other
android ui elements.  Would we then keep a raw pointer to windowAndroid for when
we want to unsubscribe in EdgeEffect?

[jdduke (slow), 2014/07/09 21:12:13]

Are there any downsides? I'm thinking perhaps we provide OverscrollGlow the raw
WindowAndroid pointer upon creation, and it would use that for subscription when
the layers are created, and when the effect is destroyed? Maybe down the road we
could have a helper type that manages the subscription automatically when the
layer is created/destroyed, but that's probably overkill now (and maybe
subscription is overkill now if it wouldn't be used by anything but the
overscroll effect, I could always add that in later?).

[powei, 2014/07/09 23:43:14]

So we'll need another interface like ui::SystemUIResourceLayer to avoid
depending on cc in ui.  Then its implementation in OverscrollGlow can serve as
the auto-subscription helper type you mentioned.

I'd like to give this a go.  I'll put this in OverscrollGlow's anon namespace
for now.  Maybe you can pull this implementation out if you'd like to do the
same for the selection handles.  WDYT?

+
  private:
   ~WindowAndroid();
 
   JavaObjectWeakGlobalRef weak_java_window_;
   gfx::Vector2dF content_offset_;
   WindowAndroidCompositor* compositor_;
   base::TimeDelta vsync_period_;
 
   ObserverList<WindowAndroidObserver> observer_list_;
 
+  typedef base::ScopedPtrHashMap<int, UIResourceClientAndroid> UIResourceMap;
+  UIResourceMap ui_resource_map_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowAndroid);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_ANDROID_WINDOW_ANDROID_H_