[Contextual Search] Add support for crushed sprites and animate the search provider icon

ui/android/resources/crushed_sprite_resource.h

+// Copyright 2015 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_ANDROID_RESOURCES_CRUSHED_SPRITE_RESOURCE_H_
+#define UI_ANDROID_RESOURCES_CRUSHED_SPRITE_RESOURCE_H_
+
+#include <utility>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "ui/android/ui_android_export.h"
+#include "ui/gfx/android/java_bitmap.h"

[David Trainor- moved to gerrit, 2015/10/15 21:04:57]

Can we forward declare this and not include it in the header?

[Theresa, 2015/10/24 00:06:46]

I can; I would also need to forward declare or include SkBitmap. Are there
guidelines for when things should be forward-declared vs included?

[David Trainor- moved to gerrit, 2015/10/27 15:14:47]

I would always forward declare if you can.

[Theresa, 2015/10/27 19:48:02]

Done.

+#include "ui/gfx/geometry/rect.h"
+
+namespace ui {
+
+// A resource that provides an unscaled bitmap and corresponding metadata for a
+// crushed sprite. A crushed sprite animation is run by drawing rectangles from
+// a bitmap to a canvas. Each frame in the animation draws its rectangles on top
+// of the previous frame.
+class UI_ANDROID_EXPORT CrushedSpriteResource :
+public base::RefCounted<CrushedSpriteResource> {

[David Trainor- moved to gerrit, 2015/10/15 21:04:58]

Does it have to be ref counted?

[Theresa, 2015/10/24 00:06:45]

I wanted it to get automatically destroyed when it wasn't being used any longer,
but I think it doesn't actually stop getting "used" until Chrome closes so, no,
it doesn't.

If I remove the RefCounted, do I need to explicitly destroy all of the
CrushedSpriteResources being held in the ResourceManager when it gets destroyed?

[David Trainor- moved to gerrit, 2015/10/27 15:14:47]

IIRC the IDMap is set to IDMapOwnPointer so it'll auto-delete the object when
it's removed from the map.

[Theresa, 2015/10/27 19:48:02]

Done.

+ public:
+  typedef std::vector<std::pair<gfx::Rect, gfx::Rect>> FrameSrcDstRects;
+  typedef std::vector<FrameSrcDstRects> SrcDstRects;
+
+  // Creates a new CrushedSpriteResource. |bitmap_res_id| is the id for the
+  // for the source bitmap, |java_bitmap| is the source bitmap for the crushed
+  // sprite, |src_dst_rects| is a list of rectangles to draw for each frame, and
+  // |sprite_size| is the size of an individual sprite.
+  static scoped_refptr<CrushedSpriteResource> CreateFromJavaBitmap(
+      int bitmap_res_id,
+      const gfx::JavaBitmap& java_bitmap,

[David Trainor- moved to gerrit, 2015/10/15 21:04:58]

Would it be better to hide the fact that this came from java from this class?

[Theresa, 2015/10/24 00:06:45]

I modeled it off the old UIResourceAndroid
https://codereview.chromium.org/1371523003/patch/160001/170002) -- since it's in
the ui/android/resources package I was expecting that all the bitmaps used to
create the CrushedSpriteResource would come from Java. But I don't have a strong
opinion on this and am okay with changing it.

[David Trainor- moved to gerrit, 2015/10/27 15:14:47]

Acknowledged.

[Theresa, 2015/10/27 19:48:02]

Changed to an SkBitmap

+      const SrcDstRects& src_dst_rects,
+      int sprite_size);
+
+  // Sets the source bitmap to |java_bitmap|.
+  void SetBitmapFromJavaBitmap(const gfx::JavaBitmap& java_bitmap);
+
+  // Returns the source bitmap.
+  SkBitmap GetBitmap();
+
+  // Stores the bitmap for the last frame and evicts the source bitmap from
+  // memory. This should be called when the crushed sprite animation finishes
+  // if it is unlikely to be rerun.
+  void SetBitmapForLastFrame(SkBitmap last_frame_bitmap);

[David Trainor- moved to gerrit, 2015/10/15 21:04:58]

I would hide a lot of this and just expose something like the following to the
ResourceManager.  That could drop the internal resource here... but you could
hold onto the metadata.

releaseCrushedSprite(int id);

Then on the next call to get the resource, reload it if necessary (maybe skip
the metadata again like you do actually... I'm not sure what the cleanest way to
do that is w.r.t. JNI and Java - store loaded ids in the Java resource loader,
have the other method like you do, etc.?).

[Theresa, 2015/10/24 00:06:46]

contextual_search_layer will call getResource each time we update the layer, but
we only need to reload the bitmap if something other than the last frame is
being displayed or the animation is being run. If we rely on getResource to
reload when necessary, I think that method will have to take a boolean to know
when it's necessary.

wrt to releasing in the ResourceManager; I could add a ReleaseCrushedSprite(int
id) method that would do something like resource->GetBitmap()->release(). I
don't really have a preference as to whether crushed_sprite_layer (or
contextual_search_layer) calls into the resource_manager or the resource itself
to release the bitmap.

[David Trainor- moved to gerrit, 2015/10/27 15:14:47]

Yeah this is the downside of sharing the bitmap through here.  We're sharing the
crushed sprite layer bitmap inside the resource which we're trying to drop
because we don't actually want the resource :(.  So this creates a situation
where we need to add these extra APIs to do this... it might be cleaner to have
the crushed_sprite_layer have a static map of some ID -> ref counted last frame
UIResource and rely on that instead or something.

[Theresa, 2015/10/27 19:48:02]

As discussed offline,removed the logic for caching the last frame on the
UIResource. I turns out to be totally unnecessary (at least for this patchset).
The resource isn't shared (and it's unlikely that animation resources will be
shared between layers in the future). If we're re-displaying the last_frame,
then the CrushedSpriteLayer actually does nothing at all since the last bitmap
set on the UIResourceLayer the CrushedSpriteLayer contains will be for the last
frame.

+
+  // Returns the bitmap for the last frame if available or an empty bitmap.
+  SkBitmap GetBitmapForLastFrame();
+
+  // Returns true if the source bitmap has been evicted from memory.
+  bool BitmapHasBeenEvictedFromMemory();
+
+  // Returns a list of rectangles to be drawn for |frame|.
+  FrameSrcDstRects GetRectanglesForFrame(int frame);
+
+  // Returns the size of an individual sprite.
+  int GetSpriteSize();
+
+  // Returns the total number of frames in the sprite animation.
+  int GetFrameCount();
+
+  // Returns the resource id for the source bitmap.
+  int GetBitmapResourceId();

[David Trainor- moved to gerrit, 2015/10/15 21:04:58]

Shouldn't be necessary I think?

[Theresa, 2015/10/24 00:06:46]

This method is currently being used to reload the resource if necessary (in
crushed_sprite_layer.cc).

+
+ private:
+  friend class base::RefCounted<CrushedSpriteResource>;
+  CrushedSpriteResource(
+      int bitmap_res_id,
+      const SkBitmap& bitmap,
+      const SrcDstRects& src_dst_rects,
+      int sprite_size);
+  ~CrushedSpriteResource();
+
+  SkBitmap bitmap_;
+  SkBitmap last_frame_bitmap_;

[David Trainor- moved to gerrit, 2015/10/15 21:04:57]

Shouldn't need?

+  SrcDstRects src_dst_rects_;
+  int sprite_size_;
+  int bitmap_res_id_;

[David Trainor- moved to gerrit, 2015/10/15 21:04:58]

We should be able to rely on the res_id from all calls to ResourceManager.

[Theresa, 2015/10/24 00:06:45]

If the call to reload the crushed sprite resource is moved to
contextual_search_layer.cc, that works. Otherwise, crushed_sprite_layer.cc needs
someway to get the res_id for the bitmap. It could just be passed from
contextual_search_layer.cc instead of stored here.

+
+  DISALLOW_COPY_AND_ASSIGN(CrushedSpriteResource);
+};
+
+}  // namespace ui
+
+#endif  // UI_ANDROID_RESOURCES_CRUSHED_SPRITE_RESOURCE_H_