[Password Manager] Copiable username and origin. Linkable origin elided from the left.

components/favicon/core/large_icon_service.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 "components/favicon/core/large_icon_service.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace {
 
 // Processes the bitmap data returned from the FaviconService as part of a
 // LargeIconService request.
 class LargeIconWorker : public base::RefCountedThreadSafe<LargeIconWorker> {
  public:
   LargeIconWorker(int min_source_size_in_pixel,
                   int desired_size_in_pixel,
+                  const favicon_base::FallbackIconStyle& fallback_icon_style,
                   favicon_base::LargeIconCallback callback,
                   scoped_refptr<base::TaskRunner> background_task_runner,
                   base::CancelableTaskTracker* tracker);
 
   // Must run on the owner (UI) thread in production.
   // Intermediate callback for GetLargeIconOrFallbackStyle(). Invokes
   // ProcessIconOnBackgroundThread() so we do not perform complex image
   // operations on the UI thread.
   void OnIconLookupComplete(
       const favicon_base::FaviconRawBitmapResult& bitmap_result);
@@ skipping 17 matching lines @@
   // into |resized_bitmap_result| and returns true.
   bool ResizeLargeIconOnBackgroundThreadIfValid(
       favicon_base::FaviconRawBitmapResult* resized_bitmap_result);
 
   // Must run on the owner (UI) thread in production.
   // Invoked when ProcessIconOnBackgroundThread() is done.
   void OnIconProcessingComplete();
 
   int min_source_size_in_pixel_;
   int desired_size_in_pixel_;
+  favicon_base::FallbackIconStyle fallback_icon_style_;
   favicon_base::LargeIconCallback callback_;
   scoped_refptr<base::TaskRunner> background_task_runner_;
   base::CancelableTaskTracker* tracker_;
   favicon_base::FaviconRawBitmapResult bitmap_result_;
   scoped_ptr<favicon_base::LargeIconResult> result_;
 
   DISALLOW_COPY_AND_ASSIGN(LargeIconWorker);
 };
 
 LargeIconWorker::LargeIconWorker(
     int min_source_size_in_pixel,
     int desired_size_in_pixel,
+    const favicon_base::FallbackIconStyle& fallback_icon_style,
     favicon_base::LargeIconCallback callback,
     scoped_refptr<base::TaskRunner> background_task_runner,
     base::CancelableTaskTracker* tracker)
     : min_source_size_in_pixel_(min_source_size_in_pixel),
       desired_size_in_pixel_(desired_size_in_pixel),
+      fallback_icon_style_(fallback_icon_style),
       callback_(callback),
       background_task_runner_(background_task_runner),
-      tracker_(tracker) {
-}
+      tracker_(tracker) {}
 
 LargeIconWorker::~LargeIconWorker() {
 }
 
 void LargeIconWorker::OnIconLookupComplete(
     const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   bitmap_result_ = bitmap_result;
   tracker_->PostTaskAndReply(
       background_task_runner_.get(), FROM_HERE,
       base::Bind(&LargeIconWorker::ProcessIconOnBackgroundThread, this),
       base::Bind(&LargeIconWorker::OnIconProcessingComplete, this));
 }
 
 void LargeIconWorker::ProcessIconOnBackgroundThread() {
   favicon_base::FaviconRawBitmapResult resized_bitmap_result;
   if (ResizeLargeIconOnBackgroundThreadIfValid(&resized_bitmap_result)) {
     result_.reset(
         new favicon_base::LargeIconResult(resized_bitmap_result));
   } else {
-    // Failed to resize |bitmap_result_|, so compute fallback icon style.
-    scoped_ptr<favicon_base::FallbackIconStyle> fallback_icon_style(
-        new favicon_base::FallbackIconStyle());
+    // Failed to resize |bitmap_result_|, so send fallback icon style.
+    favicon_base::FallbackIconStyle* style =
+        new favicon_base::FallbackIconStyle();
+    *style = fallback_icon_style_;
     if (bitmap_result_.is_valid()) {
-      favicon_base::SetDominantColorAsBackground(
-          bitmap_result_.bitmap_data, fallback_icon_style.get());
+      favicon_base::SetDominantColorAsBackground(bitmap_result_.bitmap_data,
+                                                 style);
     }
-    result_.reset(
-        new favicon_base::LargeIconResult(fallback_icon_style.release()));
+    result_.reset(new favicon_base::LargeIconResult(style));
   }
 }
 
 bool LargeIconWorker::ResizeLargeIconOnBackgroundThreadIfValid(
     favicon_base::FaviconRawBitmapResult* resized_bitmap_result) {
   // Require bitmap to be valid and square.
   if (!bitmap_result_.is_valid() ||
       bitmap_result_.pixel_size.width() != bitmap_result_.pixel_size.height())
     return false;
 
@@ skipping 44 matching lines @@
       background_task_runner_(background_task_runner) {
   large_icon_types_.push_back(favicon_base::IconType::FAVICON);
   large_icon_types_.push_back(favicon_base::IconType::TOUCH_ICON);
   large_icon_types_.push_back(favicon_base::IconType::TOUCH_PRECOMPOSED_ICON);
 }
 
 LargeIconService::~LargeIconService() {
 }
 
 base::CancelableTaskTracker::TaskId
-    LargeIconService::GetLargeIconOrFallbackStyle(
-        const GURL& page_url,
-        int min_source_size_in_pixel,
-        int desired_size_in_pixel,
-        const favicon_base::LargeIconCallback& callback,
-        base::CancelableTaskTracker* tracker) {
+LargeIconService::GetLargeIconOrFallbackStyle(
+    const GURL& page_url,
+    int min_source_size_in_pixel,
+    int desired_size_in_pixel,
+    const favicon_base::FallbackIconStyle& fallback_icon_style,
+    const favicon_base::LargeIconCallback& callback,
+    base::CancelableTaskTracker* tracker) {
   DCHECK_LE(1, min_source_size_in_pixel);
   DCHECK_LE(0, desired_size_in_pixel);
 
-  scoped_refptr<LargeIconWorker> worker =
-      new LargeIconWorker(min_source_size_in_pixel, desired_size_in_pixel,
-                          callback, background_task_runner_, tracker);
+  scoped_refptr<LargeIconWorker> worker = new LargeIconWorker(
+      min_source_size_in_pixel, desired_size_in_pixel, fallback_icon_style,
+      callback, background_task_runner_, tracker);
 
   // TODO(beaudoin): For now this is just a wrapper around
   //   GetLargestRawFaviconForPageURL. Add the logic required to select the best
   //   possible large icon. Also add logic to fetch-on-demand when the URL of
   //   a large icon is known but its bitmap is not available.
   return favicon_service_->GetLargestRawFaviconForPageURL(
       page_url, large_icon_types_, min_source_size_in_pixel,
       base::Bind(&LargeIconWorker::OnIconLookupComplete, worker),
       tracker);
 }
 
 }  // namespace favicon