Update WebAPK if homescreen icon changed.

chrome/browser/android/shortcut_helper.cc

 // 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.
 
 #include "chrome/browser/android/shortcut_helper.h"
 
 #include <jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/manifest/manifest_icon_downloader.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ShortcutHelper_jni.h"
+#include "third_party/smhasher/src/MurmurHash2.h"
 #include "ui/gfx/android/java_bitmap.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/color_analysis.h"
 #include "url/gurl.h"
 
 using content::Manifest;
 
 namespace {
 
 static int kIdealHomescreenIconSize = -1;
 static int kMinimumHomescreenIconSize = -1;
 static int kIdealSplashImageSize = -1;
 static int kMinimumSplashImageSize = -1;
 
 static int kDefaultRGBIconValue = 145;
 
+// The seed to use for the murmur2 hash.
+const uint32_t kMurmur2HashSeed = 0;
+
+// Computes a murmur2 hash of |bitmap|'s PNG encoded bytes.
+uint64_t ComputeBitmapHash(const SkBitmap& bitmap) {
+  std::vector<unsigned char> png_bytes;
+  gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &png_bytes);
+  return MurmurHash64B(&png_bytes.front(), png_bytes.size(), kMurmur2HashSeed);
+}
+
 // Retrieves and caches the ideal and minimum sizes of the Home screen icon
 // and the splash screen image.
 void GetHomescreenIconAndSplashImageSizes() {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jintArray> java_size_array =
       Java_ShortcutHelper_getHomeScreenIconAndSplashImageSizes(env);
   std::vector<int> sizes;
   base::android::JavaIntArrayToIntVector(
       env, java_size_array.obj(), &sizes);
 
@@ skipping 163 matching lines @@
   return kIdealSplashImageSize;
 }
 
 int ShortcutHelper::GetMinimumSplashImageSizeInDp() {
   if (kMinimumSplashImageSize == -1)
     GetHomescreenIconAndSplashImageSizes();
   return kMinimumSplashImageSize;
 }
 
 // static
+void ShortcutHelper::OnFetchedHomescreenImage(
+    const base::android::ScopedJavaGlobalRef<jobject> java_callback,
+    const SkBitmap& image) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  ScopedJavaLocalRef<jobject> java_bitmap;
+  uint64_t murmur2_hash = 0;
+  if (image.getSize()) {
+    java_bitmap = gfx::ConvertToJavaBitmap(&image);
+    // TODO(pkotwicz): Get hash of untransformed icon's bytes (with no
+    // encoding/decoding).
+    murmur2_hash = ComputeBitmapHash(image);
+  }
+  Java_ShortcutHelper_onFetchedHomescreenImage(
+      env, java_bitmap.obj(), murmur2_hash, java_callback.obj());
+}
+
+// static
 void ShortcutHelper::FetchSplashScreenImage(
     content::WebContents* web_contents,
     const GURL& image_url,
     const int ideal_splash_image_size_in_dp,
     const int minimum_splash_image_size_in_dp,
     const std::string& webapp_id) {
   // This is a fire and forget task. It is not vital for the splash screen image
   // to be downloaded so if the downloader returns false there is no fallback.
   ManifestIconDownloader::Download(
       web_contents, image_url, ideal_splash_image_size_in_dp,
@@ skipping 59 matching lines @@
 }
 
 // static
 bool ShortcutHelper::IsWebApkInstalled(const GURL& url) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> java_url =
       base::android::ConvertUTF8ToJavaString(env, url.spec());
   return Java_ShortcutHelper_isWebApkInstalled(env, java_url.obj());
 }
 
+/**
+ * Called by Java to fetch the image at |java_icon_url| and scale it so that it
+ * can be used on the homscreen.
+ */
+void FetchHomescreenImage(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& clazz,
+    const JavaParamRef<jobject>& java_web_contents,
+    const JavaParamRef<jstring>& java_image_url,
+    const JavaParamRef<jobject>& java_callback) {
+  content::WebContents* web_contents =
+      content::WebContents::FromJavaWebContents(java_web_contents);
+  GURL image_url = GURL(ConvertJavaStringToUTF8(env, java_image_url));
+  base::android::ScopedJavaGlobalRef<jobject> java_global_callback(
+      env, java_callback);
+
+  ManifestIconDownloader::Download(
+      web_contents, image_url, ShortcutHelper::GetIdealHomescreenIconSizeInDp(),
+      ShortcutHelper::GetMinimumHomescreenIconSizeInDp(),
+      base::Bind(&ShortcutHelper::OnFetchedHomescreenImage,
+                 java_global_callback));
+}
+
 // Callback used by Java when the shortcut has been created.
 // |splash_image_callback| is a pointer to a base::Closure allocated in
 // AddShortcutInBackgroundWithSkBitmap, so reinterpret_cast it back and run it.
 //
 // This callback should only ever be called when the shortcut was for a
 // webapp-capable site; otherwise, |splash_image_callback| will have never been
 // allocated and doesn't need to be run or deleted.
 void OnWebappDataStored(JNIEnv* env,
                         const JavaParamRef<jclass>& clazz,
                         jlong jsplash_image_callback) {
   DCHECK(jsplash_image_callback);
   base::Closure* splash_image_callback =
       reinterpret_cast<base::Closure*>(jsplash_image_callback);
   splash_image_callback->Run();
   delete splash_image_callback;
 }
 
 bool ShortcutHelper::RegisterShortcutHelper(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }