chrome/browser/enhanced_bookmarks/android/bookmark_image_service_android.cc - chromium/src - Git at Google

 // 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 "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;

 namespace enhanced_bookmarks {

 BookmarkImageServiceAndroid::BookmarkImageServiceAndroid(
     content::BrowserContext* browserContext)
     : BookmarkImageService(
           browserContext->GetPath(),
           EnhancedBookmarkModelFactory::GetForBrowserContext(browserContext),
           make_scoped_refptr(content::BrowserThread::GetBlockingPool())),
       browser_context_(browserContext) {
   // The images we're saving will be used locally. So it's wasteful to store
   // images larger than the device resolution.
   gfx::DeviceDisplayInfo display_info;
   int max_length = std::min(display_info.GetPhysicalDisplayWidth(),
                             display_info.GetPhysicalDisplayHeight());
   // GetPhysicalDisplay*() returns 0 for pre-JB MR1. If so, fall back to the
   // second best option we have.
   if (max_length == 0) {
     max_length = std::min(display_info.GetDisplayWidth(),
                           display_info.GetDisplayHeight());
   }

   if (ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_TABLET) {
     max_length = max_length / 2;
   } else if (ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_PHONE) {
     max_length = max_length * 3 / 4;
   }

   DCHECK(max_length > 0);
   max_size_.set_height(max_length);
   max_size_.set_width(max_length);
 }

 BookmarkImageServiceAndroid::~BookmarkImageServiceAndroid() {
 }

 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, image_url,
                     scoped_ptr<gfx::Image>(new gfx::Image()));
     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::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 (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(
       dom_initializer_script_,
       base::Bind(
           &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, url,
                                       update_bookmark);
     }
   }
 }

 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;
   }

   int error_code = 0;
   std::string error_message;
   scoped_ptr<base::Value> json_data = base::JSONReader::ReadAndReturnError(
       json, base::JSON_PARSE_RFC, &error_code, &error_message);
   if (error_code || !json_data) {
     LOG(WARNING) << "JSON parse error: " << error_message << 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);

   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);
 }

 scoped_ptr<gfx::Image> BookmarkImageServiceAndroid::ResizeImage(
     const gfx::Image& image) {
   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

   scoped_ptr<gfx::Image> result(new gfx::Image());

   if (image.Width() > max_size_.width() &&
       image.Height() > max_size_.height()) {
     float resize_ratio = std::min(
         ((float)max_size_.width()) / image.Width(),
         ((float)max_size_.height()) / image.Height());
     // +0.5f is for correct rounding. Without it, it's possible that dest_width
     // is smaller than max_size_.Width() by one.
     int dest_width = static_cast<int>(resize_ratio * image.Width() + 0.5f);
     int dest_height = static_cast<int>(
         resize_ratio * image.Height() + 0.5f);

     *result = gfx::Image::CreateFrom1xBitmap(
         skia::ImageOperations::Resize(image.AsBitmap(),
                                       skia::ImageOperations::RESIZE_BEST,
                                       dest_width,
                                       dest_height));
     result->AsImageSkia().MakeThreadSafe();
   } else {
     *result = image;
   }

   return result.Pass();
 }

 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_.Init(browser_context->GetRequestContext(), referrer,
                        referrer_policy, load_flags);
   bitmap_fetcher_.Start();
 }

 void BookmarkImageServiceAndroid::BitmapFetcherHandler::OnFetchComplete(
     const GURL& url,
     const SkBitmap* bitmap) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

   scoped_ptr<gfx::Image> image;
   if (bitmap) {
     gfx::ImageSkia imageSkia = gfx::ImageSkia::CreateFrom1xBitmap(*bitmap);
     imageSkia.MakeThreadSafe();
     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
	// 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 "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;

	namespace enhanced_bookmarks {

	BookmarkImageServiceAndroid::BookmarkImageServiceAndroid(
	content::BrowserContext* browserContext)
	: BookmarkImageService(
	browserContext->GetPath(),
	EnhancedBookmarkModelFactory::GetForBrowserContext(browserContext),
	make_scoped_refptr(content::BrowserThread::GetBlockingPool())),
	browser_context_(browserContext) {
	// The images we're saving will be used locally. So it's wasteful to store
	// images larger than the device resolution.
	gfx::DeviceDisplayInfo display_info;
	int max_length = std::min(display_info.GetPhysicalDisplayWidth(),
	display_info.GetPhysicalDisplayHeight());
	// GetPhysicalDisplay*() returns 0 for pre-JB MR1. If so, fall back to the
	// second best option we have.
	if (max_length == 0) {
	max_length = std::min(display_info.GetDisplayWidth(),
	display_info.GetDisplayHeight());
	}

	if (ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_TABLET) {
	max_length = max_length / 2;
	} else if (ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_PHONE) {
	max_length = max_length * 3 / 4;
	}

	DCHECK(max_length > 0);
	max_size_.set_height(max_length);
	max_size_.set_width(max_length);
	}

	BookmarkImageServiceAndroid::~BookmarkImageServiceAndroid() {
	}

	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, image_url,
	scoped_ptr<gfx::Image>(new gfx::Image()));
	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::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 (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(
	dom_initializer_script_,
	base::Bind(
	&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, url,
	update_bookmark);
	}
	}
	}

	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;
	}

	int error_code = 0;
	std::string error_message;
	scoped_ptr<base::Value> json_data = base::JSONReader::ReadAndReturnError(
	json, base::JSON_PARSE_RFC, &error_code, &error_message);
	if (error_code \|\| !json_data) {
	LOG(WARNING) << "JSON parse error: " << error_message << 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);

	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);
	}

	scoped_ptr<gfx::Image> BookmarkImageServiceAndroid::ResizeImage(
	const gfx::Image& image) {
	DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

	scoped_ptr<gfx::Image> result(new gfx::Image());

	if (image.Width() > max_size_.width() &&
	image.Height() > max_size_.height()) {
	float resize_ratio = std::min(
	((float)max_size_.width()) / image.Width(),
	((float)max_size_.height()) / image.Height());
	// +0.5f is for correct rounding. Without it, it's possible that dest_width
	// is smaller than max_size_.Width() by one.
	int dest_width = static_cast<int>(resize_ratio * image.Width() + 0.5f);
	int dest_height = static_cast<int>(
	resize_ratio * image.Height() + 0.5f);

	*result = gfx::Image::CreateFrom1xBitmap(
	skia::ImageOperations::Resize(image.AsBitmap(),
	skia::ImageOperations::RESIZE_BEST,
	dest_width,
	dest_height));
	result->AsImageSkia().MakeThreadSafe();
	} else {
	*result = image;
	}

	return result.Pass();
	}

	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_.Init(browser_context->GetRequestContext(), referrer,
	referrer_policy, load_flags);
	bitmap_fetcher_.Start();
	}

	void BookmarkImageServiceAndroid::BitmapFetcherHandler::OnFetchComplete(
	const GURL& url,
	const SkBitmap* bitmap) {
	DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

	scoped_ptr<gfx::Image> image;
	if (bitmap) {
	gfx::ImageSkia imageSkia = gfx::ImageSkia::CreateFrom1xBitmap(*bitmap);
	imageSkia.MakeThreadSafe();
	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