[NTP] Use server thumbnails from SuggestionsService on Android NTP.

chrome/browser/android/most_visited_sites.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/most_visited_sites.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/callback.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/search/suggestions/proto/suggestions.pb.h"
 #include "chrome/browser/search/suggestions/suggestions_service.h"
 #include "chrome/browser/search/suggestions/suggestions_service_factory.h"
@@ skipping 70 matching lines @@
   Java_ThumbnailCallback_onMostVisitedURLsThumbnailAvailable(
       env, j_callback->obj(), bitmap->obj());
 }
 
 void AddForcedURLOnUIThread(scoped_refptr<history::TopSites> top_sites,
                             const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   top_sites->AddForcedURL(url, base::Time::Now());
 }
 
+void OnSuggestionsThumbnailAvailable(
+    ScopedJavaGlobalRef<jobject>* j_callback,
+    const GURL& url,
+    const SkBitmap* bitmap) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  JNIEnv* env = AttachCurrentThread();
+
+  ScopedJavaGlobalRef<jobject>* j_bitmap_ref =
+      new ScopedJavaGlobalRef<jobject>();
+  if (bitmap) {
+    j_bitmap_ref->Reset(
+        env,
+        gfx::ConvertToJavaBitmap(bitmap).obj());
+  }
+
+  Java_ThumbnailCallback_onMostVisitedURLsThumbnailAvailable(
+      env, j_callback->obj(), j_bitmap_ref->obj());
+}
+
+// Runs on the DB thread.
 void GetUrlThumbnailTask(
     std::string url_string,
     scoped_refptr<TopSites> top_sites,
-    ScopedJavaGlobalRef<jobject>* j_callback) {
+    ScopedJavaGlobalRef<jobject>* j_callback,
+    base::Closure lookup_failed_ui_callback) {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaGlobalRef<jobject>* j_bitmap_ref =
       new ScopedJavaGlobalRef<jobject>();
 
   GURL gurl(url_string);
 
   scoped_refptr<base::RefCountedMemory> data;
   if (top_sites->GetPageThumbnail(gurl, false, &data)) {
     SkBitmap thumbnail_bitmap = ExtractThumbnail(*data.get());
     if (!thumbnail_bitmap.empty()) {
       j_bitmap_ref->Reset(
           env,
           gfx::ConvertToJavaBitmap(&thumbnail_bitmap).obj());
     }
   } else {
     // A thumbnail is not locally available for |gurl|. Make sure it is put in
     // the list to be fetched at the next visit to this site.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(AddForcedURLOnUIThread, top_sites, gurl));
+
+    // If appropriate, return on the UI thread to execute the proper callback.
+    if (!lookup_failed_ui_callback.is_null()) {
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE, lookup_failed_ui_callback);
+      return;
+    }
   }
 
   // Since j_callback is owned by this callback, when the callback falls out of
   // scope it will be deleted. We need to pass ownership to the next callback.
   ScopedJavaGlobalRef<jobject>* j_callback_pass =
       new ScopedJavaGlobalRef<jobject>(*j_callback);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &OnObtainedThumbnail,
           base::Owned(j_bitmap_ref), base::Owned(j_callback_pass)));
 }
 
+void GetSuggestionsThumbnailOnUIThread(
+    SuggestionsService* suggestions_service,
+    const std::string& url_string,
+    ScopedJavaGlobalRef<jobject>* j_callback) {
+  suggestions_service->GetPageThumbnail(
+      GURL(url_string),
+      base::Bind(&OnSuggestionsThumbnailAvailable,
+                 base::Owned(new ScopedJavaGlobalRef<jobject>(*j_callback))));
+}
+
 }  // namespace
 
 MostVisitedSites::MostVisitedSites(Profile* profile)
     : profile_(profile), num_sites_(0), weak_ptr_factory_(this) {
   // Register the debugging page for the Suggestions Service and the thumbnails
   // debugging page.
   content::URLDataSource::Add(profile_,
                               new suggestions::SuggestionsSource(profile_));
   content::URLDataSource::Add(profile_, new ThumbnailListSource(profile_));
 }
@@ skipping 20 matching lines @@
     // force an update now.
     top_sites->SyncWithHistory();
 
     // Register for notification when TopSites changes so that we can update
     // ourself.
     registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
                    content::Source<history::TopSites>(top_sites));
   }
 }
 
-// May be called from any thread
+// Called from the UI Thread.

[Ted C, 2014/06/02 22:36:26]

Should we DCHECK we are on the UI thread here now?

[Mathieu, 2014/06/03 15:01:55]

Done.

 void MostVisitedSites::GetURLThumbnail(JNIEnv* env,
                                        jobject obj,
                                        jstring url,
                                        jobject j_callback_obj) {
   ScopedJavaGlobalRef<jobject>* j_callback =
       new ScopedJavaGlobalRef<jobject>();
   j_callback->Reset(env, j_callback_obj);
 
   std::string url_string = ConvertJavaStringToUTF8(env, url);
   scoped_refptr<TopSites> top_sites(profile_->GetTopSites());
+
+  // If the Suggestions service is enabled, create a callback to fetch a
+  // server thumbnail from it, in case the local thumbnail is not found.
+  SuggestionsService* suggestions_service =
+      SuggestionsServiceFactory::GetForProfile(profile_);
+  base::Closure lookup_failed_callback = suggestions_service ?
+      base::Bind(&GetSuggestionsThumbnailOnUIThread,

[Ted C, 2014/06/02 22:36:26]

Out of curiosity, would it be better to batch all failed thumbnails into a
single request?  Just wondering if we should try to avoid 6 nearly concurrent
requests to the same server.

[Mathieu, 2014/06/03 15:01:55]

My next CL is going to be implementing local caching of server thumbnails
(hopefully transparent to this file). We will be able to choose whether to make
GetPageThumbnail only return a thumbnail if it's cached locally.

As well we can implement batching, but that will be in SuggestionsService. Lots
of improvements to be made for sure. 

+                 suggestions_service, url_string,
+                 base::Owned(new ScopedJavaGlobalRef<jobject>(*j_callback))) :
+      base::Closure();
   BrowserThread::PostTask(
-      BrowserThread::DB, FROM_HERE, base::Bind(
-          &GetUrlThumbnailTask,
-          url_string,
-          top_sites, base::Owned(j_callback)));
+      BrowserThread::DB, FROM_HERE,
+          base::Bind(
+              &GetUrlThumbnailTask, url_string, top_sites,
+              base::Owned(j_callback), lookup_failed_callback));
 }
 
 void MostVisitedSites::BlacklistUrl(JNIEnv* env,
                                     jobject obj,
                                     jstring j_url) {
   TopSites* top_sites = profile_->GetTopSites();
   if (!top_sites)
     return;
 
   std::string url_string = ConvertJavaStringToUTF8(env, j_url);
@@ skipping 68 matching lines @@
       j_observer->obj(),
       ToJavaArrayOfStrings(env, titles).obj(),
       ToJavaArrayOfStrings(env, urls).obj());
 }
 
 static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) {
   MostVisitedSites* most_visited_sites =
       new MostVisitedSites(ProfileAndroid::FromProfileAndroid(jprofile));
   return reinterpret_cast<intptr_t>(most_visited_sites);
 }