[Enhanced Bookmark]Upstream image fetching code in android

This CL added the image fetching code that previously lived in clank private repository.

Also I moved android enhanced_bookmark_bridge from
chrome/browser/android/enhanced_bookmarks/ to chrome/browser/enhanced_bookmarks/android,
since the latter is a more unified place to put all files in.(I deleted the
android/enhanced_bookmarks folder).

Last but not least, I made some small changes to the internal implementation of
bookmark_image_service, making it more readable.

The previously private code can be found in code search:
https://cs.corp.google.com/#clankium/src/clank/native/framework/chrome/enhanced_bookmarks/

Downstream CL: https://chrome-internal-review.googlesource.com/#/c/195438/
BUG=454623

Review URL: https://codereview.chromium.org/899653003

Cr-Commit-Position: refs/heads/master@{#314872}

chrome/android/java/src/org/chromium/chrome/browser/EnhancedBookmarksBridge.java

@@ -4,6 +4,10 @@
 
 package org.chromium.chrome.browser;
 
+import android.graphics.Bitmap;
+import android.util.LruCache;
+import android.util.Pair;
+
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.ObserverList;
@@ -13,6 +17,7 @@ import org.chromium.components.bookmarks.BookmarkId;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Access gate to C++ side enhanced bookmarks functionalities.
@@ -25,6 +30,22 @@ public final class EnhancedBookmarksBridge {
     private final ObserverList<SearchServiceObserver> mSearchObservers =
             new ObserverList<SearchServiceObserver>();
 
+    private LruCache<String, Pair<String, Bitmap>> mSalientImageCache;
+
+    /**
+     * Interface for getting result back from SalientImageForUrl function.
+     */
+    public interface SalientImageCallback {
+        /**
+         * Callback method for fetching salient image.
+         * @param image Salient image. This can be null if the image cannot be found.
+         * @param imageUrl Url of the image. Note this is not the same as the url of the website
+         *            containing the image.
+         */
+        @CalledByNative("SalientImageCallback")
+        void onSalientImageReady(Bitmap image, String imageUrl);
+    }
+
     /**
      * Interface to provide consumers notifications to changes in clusters
      */
@@ -46,6 +67,19 @@ public final class EnhancedBookmarksBridge {
         void onSearchResultsReturned();
     }
 
+    public EnhancedBookmarksBridge(Profile profile, int maxCacheSize) {
+        this(profile);
+        // Do not initialize LruCache if cache size is set to 0.
+        if (maxCacheSize != 0) {
+            mSalientImageCache = new LruCache<String, Pair<String, Bitmap>>(maxCacheSize) {
+                @Override
+                protected int sizeOf(String key, Pair<String, Bitmap> urlImage) {
+                    return urlImage.first.length() + urlImage.second.getByteCount();
+                }
+            };
+        }
+    }
+
     public EnhancedBookmarksBridge(Profile profile) {
         mNativeEnhancedBookmarksBridge = nativeInit(profile);
     }
@@ -54,6 +88,14 @@ public final class EnhancedBookmarksBridge {
         assert mNativeEnhancedBookmarksBridge != 0;
         nativeDestroy(mNativeEnhancedBookmarksBridge);
         mNativeEnhancedBookmarksBridge = 0;
+
+        if (mSalientImageCache != null) {
+            for (Map.Entry<String, Pair<String, Bitmap>> entry :
+                    mSalientImageCache.snapshot().entrySet()) {
+                entry.getValue().second.recycle();
+            }
+            mSalientImageCache.evictAll();
+        }
     }
 
     /**
@@ -170,6 +212,39 @@ public final class EnhancedBookmarksBridge {
         mSearchObservers.removeObserver(observer);
     }
 
+    /**
+     * Request bookmark salient image for the given URL. Please refer to
+     * |BookmarkImageService::SalientImageForUrl|.
+     * @return True if this method is executed synchronously. False if
+     *         {@link SalientImageCallback#onSalientImageReady(Bitmap, String)} is called later
+     *         (asynchronously).
+     */
+    public boolean salientImageForUrl(final String url, final SalientImageCallback callback) {
+        assert callback != null;
+        SalientImageCallback callbackWrapper = callback;
+
+        if (mSalientImageCache != null) {
+            Pair<String, Bitmap> cached = mSalientImageCache.get(url);
+            if (cached != null) {
+                callback.onSalientImageReady(cached.second, cached.first);
+                return true;
+            }
+
+            callbackWrapper = new SalientImageCallback() {
+                @Override
+                public void onSalientImageReady(Bitmap image, String imageUrl) {
+                    if (image != null) {
+                        mSalientImageCache.put(url, new Pair<String, Bitmap>(imageUrl, image));
+                    }
+                    callback.onSalientImageReady(image, imageUrl);
+                }
+            };
+        }
+
+        nativeSalientImageForUrl(mNativeEnhancedBookmarksBridge, url, callbackWrapper);
+        return false;
+    }
+
     /**
      * Get all filters associated with the given bookmark.
      *
@@ -235,4 +310,6 @@ public final class EnhancedBookmarksBridge {
     private native BookmarkId nativeAddBookmark(long nativeEnhancedBookmarksBridge,
             BookmarkId parent, int index, String title, String url);
     private native void nativeSendSearchRequest(long nativeEnhancedBookmarksBridge, String query);
+    private static native void nativeSalientImageForUrl(long nativeEnhancedBookmarksBridge,
+            String url, SalientImageCallback callback);
 }

chrome/browser/android/chrome_jni_registrar.cc

@@ -25,7 +25,6 @@
 #include "chrome/browser/android/dev_tools_server.h"
 #include "chrome/browser/android/dom_distiller/feedback_reporter_android.h"
 #include "chrome/browser/android/download/chrome_download_delegate.h"
-#include "chrome/browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.h"
 #include "chrome/browser/android/favicon_helper.h"
 #include "chrome/browser/android/feature_utilities.h"
 #include "chrome/browser/android/find_in_page/find_in_page_bridge.h"
@@ -57,6 +56,7 @@
 #include "chrome/browser/autofill/android/personal_data_manager_android.h"
 #include "chrome/browser/dom_distiller/dom_distiller_service_factory_android.h"
 #include "chrome/browser/dom_distiller/tab_utils_android.h"
+#include "chrome/browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.h"
 #include "chrome/browser/history/android/sqlite_cursor.h"
 #include "chrome/browser/invalidation/invalidation_service_factory_android.h"
 #include "chrome/browser/lifetime/application_lifetime_android.h"

chrome/browser/android/enhanced_bookmarks/OWNERS

-kkimlabs@chromium.org

chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.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 "base/json/json_parser.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.h"
+#include "chrome/browser/enhanced_bookmarks/enhanced_bookmark_model_factory.h"
+#include "chrome/grit/browser_resources.h"
+#include "components/bookmarks/browser/bookmark_model.h"
+#include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/referrer.h"
+#include "net/base/load_flags.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/image/image_skia.h"
+
+using content::Referrer;
+using bookmarks::BookmarkNode;
+
+namespace enhanced_bookmarks {
+
+BookmarkImageServiceAndroid::BookmarkImageServiceAndroid(
+    content::BrowserContext* browserContext)
+    : BookmarkImageService(
+          browserContext->GetPath(),
+          EnhancedBookmarkModelFactory::GetForBrowserContext(browserContext),
+          make_scoped_refptr(content::BrowserThread::GetBlockingPool())),
+      browser_context_(browserContext) {
+}
+
+void BookmarkImageServiceAndroid::RetrieveSalientImage(
+    const GURL& page_url,
+    const GURL& image_url,
+    const std::string& referrer,
+    net::URLRequest::ReferrerPolicy referrer_policy,
+    bool update_bookmark) {
+  const BookmarkNode* bookmark =
+      enhanced_bookmark_model_->bookmark_model()
+          ->GetMostRecentlyAddedUserNodeForURL(page_url);
+  if (!bookmark || !image_url.is_valid()) {
+    ProcessNewImage(page_url, update_bookmark, gfx::Image(), image_url);
+    return;
+  }
+
+  BitmapFetcherHandler* bitmap_fetcher_handler =
+      new BitmapFetcherHandler(this, image_url);
+  bitmap_fetcher_handler->Start(
+      browser_context_, referrer, referrer_policy,
+      net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES,
+      update_bookmark, page_url);
+}
+
+void BookmarkImageServiceAndroid::RetrieveSalientImageFromContext(
+    content::RenderFrameHost* render_frame_host,
+    const GURL& page_url,
+    bool update_bookmark) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (IsPageUrlInProgress(page_url))
+    return;  // A request for this URL is already in progress.
+
+  const BookmarkNode* bookmark = enhanced_bookmark_model_->bookmark_model()
+          ->GetMostRecentlyAddedUserNodeForURL(page_url);
+  if (!bookmark)
+    return;
+
+  // Stop the image extraction if there is already an image present.
+  GURL url;
+  int height, width;
+  if (enhanced_bookmark_model_->GetOriginalImage(bookmark, &url, &width,
+                                                 &height) ||
+      enhanced_bookmark_model_->GetThumbnailImage(bookmark, &url, &width,
+                                                  &height)) {
+    return;
+  }
+
+  if (script_.empty()) {
+    script_ =
+        base::UTF8ToUTF16(ResourceBundle::GetSharedInstance()
+                              .GetRawDataResource(IDR_GET_SALIENT_IMAGE_URL_JS)
+                              .as_string());
+  }
+
+  render_frame_host->ExecuteJavaScript(
+      script_,
+      base::Bind(
+          &BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback,
+          base::Unretained(this), page_url, update_bookmark));
+}
+
+void BookmarkImageServiceAndroid::FinishSuccessfulPageLoadForTab(
+    content::WebContents* web_contents, bool update_bookmark) {
+  content::NavigationEntry* entry =
+      web_contents->GetController().GetVisibleEntry();
+
+  // If the navigation is a simple back or forward, do not extract images, those
+  // were extracted already.
+  if (!entry || (entry->GetTransitionType() & ui::PAGE_TRANSITION_FORWARD_BACK))
+    return;
+  const GURL& entry_url = entry->GetURL();
+  const GURL& entry_original_url = entry->GetOriginalRequestURL();
+  std::vector<GURL> urls;
+  urls.push_back(entry_url);
+  if (entry_url != entry_original_url)
+    urls.push_back(entry_original_url);
+  for (GURL url : urls) {
+    if (enhanced_bookmark_model_->bookmark_model()->IsBookmarked(url)) {
+      RetrieveSalientImageFromContext(web_contents->GetMainFrame(), url,
+                                      update_bookmark);
+    }
+  }
+}
+
+void BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback(
+    const GURL& page_url,
+    bool update_bookmark,
+    const base::Value* result) {
+  if (!result)
+    return;
+
+  std::string json;
+  if (!result->GetAsString(&json)) {
+    LOG(WARNING)
+        << "Salient image extracting script returned non-string result.";
+    return;
+  }
+
+  scoped_ptr<base::Value> json_data;
+  int error_code = 0;
+  std::string errorMessage;
+  json_data.reset(base::JSONReader::ReadAndReturnError(
+      json, base::JSON_PARSE_RFC, &error_code, &errorMessage));
+  if (error_code || !json_data) {
+    LOG(WARNING) << "JSON parse error: " << errorMessage.c_str() << json;
+    return;
+  }
+
+  base::DictionaryValue* dict;
+  if (!json_data->GetAsDictionary(&dict)) {
+    LOG(WARNING) << "JSON parse error, not a dict: " << json;
+    return;
+  }
+
+  std::string referrerPolicy;
+  std::string image_url;
+  dict->GetString("referrerPolicy", &referrerPolicy);
+  dict->GetString("imageUrl", &image_url);
+
+  // The policy strings are guaranteed to be in lower-case.
+  blink::WebReferrerPolicy policy = blink::WebReferrerPolicyDefault;
+  if (referrerPolicy == "never")
+    policy = blink::WebReferrerPolicyNever;
+  if (referrerPolicy == "always")
+    policy = blink::WebReferrerPolicyAlways;
+  if (referrerPolicy == "origin")
+    policy = blink::WebReferrerPolicyOrigin;
+
+  in_progress_page_urls_.insert(page_url);
+
+  Referrer referrer =
+      Referrer::SanitizeForRequest(GURL(image_url), Referrer(page_url, policy));
+  net::URLRequest::ReferrerPolicy referrer_policy =
+      net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
+  if (!referrer.url.is_empty()) {
+    switch (policy) {
+      case blink::WebReferrerPolicyDefault:
+        break;
+      case blink::WebReferrerPolicyAlways:
+      case blink::WebReferrerPolicyNever:
+      case blink::WebReferrerPolicyOrigin:
+        referrer_policy = net::URLRequest::NEVER_CLEAR_REFERRER;
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+  RetrieveSalientImage(page_url, GURL(image_url), referrer.url.spec(),
+                       referrer_policy, update_bookmark);
+}
+
+void BookmarkImageServiceAndroid::BitmapFetcherHandler::Start(
+    content::BrowserContext* browser_context,
+    const std::string& referrer,
+    net::URLRequest::ReferrerPolicy referrer_policy,
+    int load_flags,
+    bool update_bookmark,
+    const GURL& page_url) {
+  update_bookmark_ = update_bookmark;
+  page_url_ = page_url;
+
+  bitmap_fetcher_.Start(browser_context->GetRequestContext(), referrer,
+                        referrer_policy, load_flags);
+}
+
+void BookmarkImageServiceAndroid::BitmapFetcherHandler::OnFetchComplete(
+    const GURL url,
+    const SkBitmap* bitmap) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  gfx::Image image;
+  if (bitmap) {
+    gfx::ImageSkia imageSkia = gfx::ImageSkia::CreateFrom1xBitmap(*bitmap);
+    imageSkia.MakeThreadSafe();
+    image = gfx::Image(imageSkia);
+  }
+  service_->ProcessNewImage(page_url_, update_bookmark_, image, url);
+
+  delete this;
+}
+
+}  // namespace enhanced_bookmarks

chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.h

+// 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.
+
+#ifndef CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_ANDROID_H_
+#define CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_ANDROID_H_
+
+#include "components/enhanced_bookmarks/bookmark_image_service.h"
+#include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
+
+namespace chrome {
+class BitmapFetcher;
+}
+
+namespace content {
+class BrowserContext;
+class RenderFrameHost;
+class WebContents;
+}
+
+namespace enhanced_bookmarks {
+
+class BookmarkImageServiceAndroid : public BookmarkImageService {
+ public:
+  explicit BookmarkImageServiceAndroid(content::BrowserContext* browserContext);
+
+  void RetrieveSalientImage(const GURL& page_url,
+                            const GURL& image_url,
+                            const std::string& referrer,
+                            net::URLRequest::ReferrerPolicy referrer_policy,
+                            bool update_bookmark) override;
+
+  // Searches the current page for a salient image, if a url is found the image
+  // is fetched and stored.
+  void RetrieveSalientImageFromContext(
+      content::RenderFrameHost* render_frame_host,
+      const GURL& page_url,
+      bool update_bookmark);
+
+  // Investigates if the tab points to a bookmarked url in needs of an updated
+  // image. If it is, invokes RetrieveSalientImageFromContext() for the relevant
+  // urls.
+  void FinishSuccessfulPageLoadForTab(content::WebContents* web_contents,
+                                      bool update_bookmark);
+
+ private:
+  void RetrieveSalientImageFromContextCallback(const GURL& page_url,
+                                               bool update_bookmark,
+                                               const base::Value* result);
+
+  content::BrowserContext* browser_context_;
+  // The script injected in a page to extract image urls.
+  base::string16 script_;
+
+  class BitmapFetcherHandler : private chrome::BitmapFetcherDelegate {
+   public:
+    explicit BitmapFetcherHandler(BookmarkImageServiceAndroid* service,
+                                  const GURL& image_url)
+        : service_(service), bitmap_fetcher_(image_url, this) {}
+    void Start(content::BrowserContext* browser_context,
+               const std::string& referrer,
+               net::URLRequest::ReferrerPolicy referrer_policy,
+               int load_flags,
+               bool update_bookmark,
+               const GURL& page_url);
+    void OnFetchComplete(const GURL url, const SkBitmap* bitmap) override;
+
+   protected:
+    ~BitmapFetcherHandler() override {}
+
+   private:
+    BookmarkImageServiceAndroid* service_;
+    chrome::BitmapFetcher bitmap_fetcher_;
+    bool update_bookmark_;
+    GURL page_url_;
+
+    DISALLOW_COPY_AND_ASSIGN(BitmapFetcherHandler);
+  };
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkImageServiceAndroid);
+};
+
+}  // namespace enhanced_bookmarks
+
+#endif  // CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_ANDROID_H_

chrome/browser/enhanced_bookmarks/android/bookmark_image_service_factory.cc

+// 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.
+
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.h"
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_factory.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "content/public/browser/browser_context.h"
+
+namespace enhanced_bookmarks {
+
+// static
+BookmarkImageServiceFactory* BookmarkImageServiceFactory::GetInstance() {
+  return Singleton<BookmarkImageServiceFactory>::get();
+}
+
+// static
+BookmarkImageService* BookmarkImageServiceFactory::GetForBrowserContext(
+    content::BrowserContext* context) {
+  return static_cast<BookmarkImageService*>(
+      GetInstance()->GetServiceForBrowserContext(context, true));
+}
+
+BookmarkImageServiceFactory::BookmarkImageServiceFactory()
+    : BrowserContextKeyedServiceFactory(
+          "BookmarkExtendedStorageService",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+BookmarkImageServiceFactory::~BookmarkImageServiceFactory() {}
+
+content::BrowserContext* BookmarkImageServiceFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return context;
+}
+
+BookmarkImageService* BookmarkImageServiceFactory::BuildServiceInstanceFor(
+    content::BrowserContext* browser_context) const {
+  return new BookmarkImageServiceAndroid(browser_context);
+}
+
+}  // namespace enhanced_bookmarks

chrome/browser/enhanced_bookmarks/android/bookmark_image_service_factory.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 CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_FACTORY_H_
+#define CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_FACTORY_H_
+
+#include "components/enhanced_bookmarks/bookmark_image_service.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace enhanced_bookmarks {
+
+class BookmarkImageServiceFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static BookmarkImageServiceFactory* GetInstance();
+  static BookmarkImageService* GetForBrowserContext(
+      content::BrowserContext* context);
+
+  virtual ~BookmarkImageServiceFactory();
+
+ private:
+  friend struct DefaultSingletonTraits<BookmarkImageServiceFactory>;
+
+  BookmarkImageServiceFactory();
+
+  BookmarkImageService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+};
+
+}  // namespace enhanced_bookmarks
+
+#endif  // CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_BOOKMARK_IMAGE_SERVICE_FACTORY_H_

chrome/browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.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 "chrome/browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.h"
+
+#include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.h"
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_factory.h"
+#include "chrome/browser/profiles/profile.h"
+
+using enhanced_bookmarks::BookmarkImageServiceAndroid;
+using enhanced_bookmarks::BookmarkImageServiceFactory;
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(EnhancedBookmarkTabHelper);
+
+void EnhancedBookmarkTabHelper::DocumentOnLoadCompletedInMainFrame() {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
+
+  if (profile->IsOffTheRecord())
+    return;
+
+  bool is_enhanced_bookmarks_enabled =
+      IsEnhancedBookmarksEnabled(profile->GetPrefs());
+  if (!is_enhanced_bookmarks_enabled)
+    return;
+
+  BookmarkImageServiceAndroid* storage =
+      static_cast<BookmarkImageServiceAndroid*>(
+          BookmarkImageServiceFactory::GetForBrowserContext(profile));
+  storage->FinishSuccessfulPageLoadForTab(web_contents(),
+                                          is_enhanced_bookmarks_enabled);
+}
+
+EnhancedBookmarkTabHelper::EnhancedBookmarkTabHelper(
+    content::WebContents* contents)
+    : content::WebContentsObserver(contents) {
+}

chrome/browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.h

+// 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.
+
+#ifndef CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARK_TAB_HELPER_H_
+#define CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARK_TAB_HELPER_H_
+
+#include "base/macros.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents_user_data.h"
+
+class EnhancedBookmarkTabHelper
+    : public content::WebContentsObserver,
+      public content::WebContentsUserData<EnhancedBookmarkTabHelper> {
+ public:
+  ~EnhancedBookmarkTabHelper() override {};
+
+  // content::WebContentsObserver overrides.
+  void DocumentOnLoadCompletedInMainFrame() override;
+
+ private:
+  explicit EnhancedBookmarkTabHelper(content::WebContents* contents);
+  friend class content::WebContentsUserData<EnhancedBookmarkTabHelper>;
+
+  DISALLOW_COPY_AND_ASSIGN(EnhancedBookmarkTabHelper);
+};
+
+#endif  // CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARK_TAB_HELPER_H_

chrome/browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.cc → chrome/browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.cc

@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.h"
+#include "chrome/browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.h"
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/enhanced_bookmarks/android/bookmark_image_service_factory.h"
 #include "chrome/browser/enhanced_bookmarks/chrome_bookmark_server_cluster_service.h"
 #include "chrome/browser/enhanced_bookmarks/chrome_bookmark_server_cluster_service_factory.h"
 #include "chrome/browser/enhanced_bookmarks/enhanced_bookmark_model_factory.h"
@@ -20,18 +21,46 @@
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/common/android/bookmark_id.h"
 #include "components/bookmarks/common/android/bookmark_type.h"
+#include "components/enhanced_bookmarks/bookmark_image_service.h"
 #include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
+#include "components/enhanced_bookmarks/image_record.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/EnhancedBookmarksBridge_jni.h"
+#include "ui/gfx/android/java_bitmap.h"
+#include "ui/gfx/image/image.h"
 
 using base::android::AttachCurrentThread;
+using base::android::ScopedJavaGlobalRef;
 using bookmarks::android::JavaBookmarkIdCreateBookmarkId;
 using bookmarks::android::JavaBookmarkIdGetId;
 using bookmarks::android::JavaBookmarkIdGetType;
 using bookmarks::BookmarkNode;
 using bookmarks::BookmarkType;
 using content::BrowserThread;
+using enhanced_bookmarks::ImageRecord;
+
+namespace {
+
+void Callback(ScopedJavaGlobalRef<jobject>* j_callback,
+              const ImageRecord& image_record) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  scoped_ptr<ScopedJavaGlobalRef<jobject> > j_callback_ptr(j_callback);
+  ScopedJavaLocalRef<jstring> j_url =
+      base::android::ConvertUTF8ToJavaString(env, image_record.url.spec());
+
+  SkBitmap bitmap = image_record.image.AsBitmap();
+  ScopedJavaLocalRef<jobject> j_bitmap;
+  if (!bitmap.isNull()) {
+    j_bitmap = gfx::ConvertToJavaBitmap(&bitmap);
+  }
+
+  enhanced_bookmarks::android::Java_SalientImageCallback_onSalientImageReady(
+      env, j_callback_ptr->obj(), j_bitmap.Release(), j_url.Release());
+}
+
+}  // namespace
 
 namespace enhanced_bookmarks {
 namespace android {
@@ -46,6 +75,8 @@ EnhancedBookmarksBridge::EnhancedBookmarksBridge(JNIEnv* env,
   cluster_service_ =
       ChromeBookmarkServerClusterServiceFactory::GetForBrowserContext(profile_);
   cluster_service_->AddObserver(this);
+  bookmark_image_service_ =
+      BookmarkImageServiceFactory::GetForBrowserContext(profile_);
   search_service_.reset(new BookmarkServerSearchService(
       profile_->GetRequestContext(),
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
@@ -63,6 +94,20 @@ void EnhancedBookmarksBridge::Destroy(JNIEnv*, jobject) {
   delete this;
 }
 
+void EnhancedBookmarksBridge::SalientImageForUrl(JNIEnv* env,
+                                                 jobject obj,
+                                                 jstring j_url,
+                                                 jobject j_callback) {
+  DCHECK(j_callback);
+
+  GURL url(base::android::ConvertJavaStringToUTF16(env, j_url));
+  scoped_ptr<ScopedJavaGlobalRef<jobject>> j_callback_ptr(
+      new ScopedJavaGlobalRef<jobject>());
+  j_callback_ptr->Reset(env, j_callback);
+  bookmark_image_service_->SalientImageForUrl(
+      url, base::Bind(&Callback, j_callback_ptr.release()));
+}
+
 ScopedJavaLocalRef<jstring> EnhancedBookmarksBridge::GetBookmarkDescription(
     JNIEnv* env, jobject obj, jlong id, jint type) {
   DCHECK(enhanced_bookmark_model_->loaded());
@@ -244,7 +289,7 @@ void EnhancedBookmarksBridge::OnChange(BookmarkServerService* service) {
 
   if (service == cluster_service_) {
     Java_EnhancedBookmarksBridge_onFiltersChanged(env, obj.obj());
-  } else if (service == search_service_.get()){
+  } else if (service == search_service_.get()) {
     Java_EnhancedBookmarksBridge_onSearchResultReturned(env, obj.obj());
   }
 }

chrome/browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.h → chrome/browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_ANDROID_ENHANCED_BOOKMARKS_ENHANCED_BOOKMARKS_BRIDGE_H_
-#define CHROME_BROWSER_ANDROID_ENHANCED_BOOKMARKS_ENHANCED_BOOKMARKS_BRIDGE_H_
+#ifndef CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARKS_BRIDGE_H_
+#define CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARKS_BRIDGE_H_
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_weak_ref.h"
@@ -15,6 +15,7 @@
 namespace enhanced_bookmarks {
 
 class BookmarkServerClusterService;
+class BookmarkImageService;
 
 namespace android {
 
@@ -24,6 +25,11 @@ class EnhancedBookmarksBridge : public BookmarkServerServiceObserver {
   ~EnhancedBookmarksBridge() override;
   void Destroy(JNIEnv*, jobject);
 
+  void SalientImageForUrl(JNIEnv* env,
+                          jobject obj,
+                          jstring j_url,
+                          jobject j_callback);
+
   base::android::ScopedJavaLocalRef<jstring> GetBookmarkDescription(
       JNIEnv* env,
       jobject obj,
@@ -79,8 +85,9 @@ class EnhancedBookmarksBridge : public BookmarkServerServiceObserver {
   bool IsEditable(const bookmarks::BookmarkNode* node) const;
 
   JavaObjectWeakGlobalRef weak_java_ref_;
-  EnhancedBookmarkModel* enhanced_bookmark_model_; // weak
-  BookmarkServerClusterService* cluster_service_;  // weak
+  EnhancedBookmarkModel* enhanced_bookmark_model_;  // weak
+  BookmarkServerClusterService* cluster_service_;   // weak
+  BookmarkImageService* bookmark_image_service_;    // weak
   scoped_ptr<BookmarkServerSearchService> search_service_;
   Profile* profile_;                       // weak
   DISALLOW_COPY_AND_ASSIGN(EnhancedBookmarksBridge);
@@ -91,4 +98,4 @@ bool RegisterEnhancedBookmarksBridge(JNIEnv* env);
 }  // namespace android
 }  // namespace enhanced_bookmarks
 
-#endif  // CHROME_BROWSER_ANDROID_ENHANCED_BOOKMARKS_ENHANCED_BOOKMARKS_BRIDGE_H_
+#endif  // CHROME_BROWSER_ENHANCED_BOOKMARKS_ANDROID_ENHANCED_BOOKMARKS_BRIDGE_H_

chrome/browser/ui/tab_helpers.cc

@@ -39,6 +39,7 @@
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/webapps/single_tab_mode_tab_helper.h"
+#include "chrome/browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.h"
 #include "chrome/browser/ui/android/context_menu_helper.h"
 #include "chrome/browser/ui/android/window_android_helper.h"
 #else
@@ -161,6 +162,7 @@ void TabHelpers::AttachTabHelpers(WebContents* web_contents) {
 
 #if defined(OS_ANDROID)
   ContextMenuHelper::CreateForWebContents(web_contents);
+  EnhancedBookmarkTabHelper::CreateForWebContents(web_contents);
   SingleTabModeTabHelper::CreateForWebContents(web_contents);
   WindowAndroidHelper::CreateForWebContents(web_contents);
 #else

chrome/chrome_browser.gypi

@@ -84,8 +84,8 @@
       'browser/android/dom_distiller/feedback_reporter_android.h',
       'browser/android/download/chrome_download_delegate.cc',
       'browser/android/download/chrome_download_delegate.h',
-      'browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.cc',
-      'browser/android/enhanced_bookmarks/enhanced_bookmarks_bridge.h',
+      'browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.cc',
+      'browser/enhanced_bookmarks/android/enhanced_bookmarks_bridge.h',
       'browser/android/favicon_helper.cc',
       'browser/android/favicon_helper.h',
       'browser/android/feature_utilities.cc',
@@ -1193,6 +1193,12 @@
       'browser/bookmarks/chrome_bookmark_client_factory.h',
       'browser/bookmarks/enhanced_bookmarks_features.cc',
       'browser/bookmarks/enhanced_bookmarks_features.h',
+      'browser/enhanced_bookmarks/android/bookmark_image_service_android.cc',
+      'browser/enhanced_bookmarks/android/bookmark_image_service_android.h',
+      'browser/enhanced_bookmarks/android/bookmark_image_service_factory.cc',
+      'browser/enhanced_bookmarks/android/bookmark_image_service_factory.h',
+      'browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.cc',
+      'browser/enhanced_bookmarks/android/enhanced_bookmark_tab_helper.h',
       'browser/enhanced_bookmarks/chrome_bookmark_server_cluster_service.cc',
       'browser/enhanced_bookmarks/chrome_bookmark_server_cluster_service.h',
       'browser/enhanced_bookmarks/chrome_bookmark_server_cluster_service_factory.cc',

components/enhanced_bookmarks/bookmark_image_service.cc

@@ -166,7 +166,7 @@ void BookmarkImageService::FetchCallback(const GURL& page_url,
 }
 
 void BookmarkImageService::SalientImageForUrl(const GURL& page_url,
-                                              bool fetch_from_bookmark,
+                                              bool fetch_from_web,
                                               ImageCallback callback) {
   DCHECK(CalledOnValidThread());
 
@@ -177,7 +177,7 @@ void BookmarkImageService::SalientImageForUrl(const GURL& page_url,
     return;
   }
 
-  if (!fetch_from_bookmark) {
+  if (!fetch_from_web) {
     RetrieveImageFromStore(page_url, callback);
   } else {
     RetrieveImageFromStore(page_url,

components/enhanced_bookmarks/bookmark_image_service.h

@@ -84,8 +84,8 @@ class BookmarkImageService : public KeyedService,
   // Returns true if the image for the page_url is currently being fetched.
   bool IsPageUrlInProgress(const GURL& page_url);
 
-  // Once an image has been retrieved, store the image and notify all the
-  // consumers that were waiting on it.
+  // Stores the image to local storage. If update_bookmarks is true, relates the
+  // corresponding bookmark to image_url.
   void ProcessNewImage(const GURL& page_url,
                        bool update_bookmarks,
                        const gfx::Image& image,
@@ -113,10 +113,10 @@ class BookmarkImageService : public KeyedService,
   EnhancedBookmarkModel* enhanced_bookmark_model_;
 
  private:
-  // Same as SalientImageForUrl(const GURL&, ImageCallback) but can
-  // prevent the network request if fetch_from_bookmark is false.
+  // If fetch_from_web is true, retrieves the salient image via a network
+  // request; else only gets the image from local storage.
   void SalientImageForUrl(const GURL& page_url,
-                          bool fetch_from_bookmark,
+                          bool fetch_from_web,
                           ImageCallback stack_callback);
 
   // Processes the requests that have been waiting on an image.