Revert "Revert of Refactor get_salient_image_url.js to use DocumentImageExtractor"

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 "chrome/renderer/chrome_isolated_world_ids.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 "grit/enhanced_bookmarks_resources.h"
 #include "net/base/load_flags.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/device_form_factor.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::Referrer;
 using bookmarks::BookmarkNode;
 
@@ skipping 49 matching lines @@
 
   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,
+    content::WebContents* web_contents,
     const GURL& page_url,
     bool update_bookmark) {
   DCHECK_CURRENTLY_ON(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());
+  if (dom_initializer_script_.empty()) {
+    dom_initializer_script_ =
+        base::UTF8ToUTF16(
+            ResourceBundle::GetSharedInstance()
+                .GetRawDataResource(IDR_DOM_INITIALIZER_GEN_JS)
+                .as_string());
   }
 
+  blink::WebReferrerPolicy policy =
+      web_contents->GetController().GetVisibleEntry()->GetReferrer().policy;
+
+  content::RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
+
   render_frame_host->ExecuteJavaScriptInIsolatedWorld(
-      script_,
+      dom_initializer_script_,
       base::Bind(
-          &BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback,
-          base::Unretained(this), page_url, update_bookmark),
+          &BookmarkImageServiceAndroid::InitializeDomCallback,
+          base::Unretained(this), policy, render_frame_host, page_url,
+          update_bookmark),
       chrome::ISOLATED_WORLD_ID_CHROME_INTERNAL);
 }
 
 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,
+      RetrieveSalientImageFromContext(web_contents, url,
                                       update_bookmark);
     }
   }
 }
 
-void BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback(
+void BookmarkImageServiceAndroid::InitializeDomCallback(
+    blink::WebReferrerPolicy policy,
+    content::RenderFrameHost* render_frame_host,
     const GURL& page_url,
     bool update_bookmark,
     const base::Value* result) {
+  if (get_salient_image_url_script_.empty()) {
+    get_salient_image_url_script_ =
+        base::UTF8ToUTF16(
+            ResourceBundle::GetSharedInstance()
+                .GetRawDataResource(IDR_GET_SALIENT_IMAGE_URL_GEN_JS)
+                .as_string());
+  }
+
+  render_frame_host->ExecuteJavaScriptInIsolatedWorld(
+      get_salient_image_url_script_,
+      base::Bind(
+          &BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback,
+          base::Unretained(this), policy, page_url, update_bookmark),
+      chrome::ISOLATED_WORLD_ID_CHROME_INTERNAL);
+}
+
+void BookmarkImageServiceAndroid::RetrieveSalientImageFromContextCallback(
+    blink::WebReferrerPolicy policy,
+    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;
   }
 
@@ skipping 10 matching lines @@
   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;
@@ skipping 66 matching lines @@
     image.reset(new gfx::Image(imageSkia));
   } else {
     image.reset(new gfx::Image());
   }
   service_->ProcessNewImage(page_url_, update_bookmark_, url, image.Pass());
 
   delete this;
 }
 
 }  // namespace enhanced_bookmarks