Fix NTP thumbnail generation

chrome/browser/thumbnails/content_based_thumbnailing_algorithm.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/thumbnails/content_based_thumbnailing_algorithm.h"
 
 #include "base/metrics/histogram.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/thumbnails/content_analysis.h"
 #include "chrome/browser/thumbnails/simple_thumbnail_crop.h"
@@ skipping 58 matching lines @@
       SimpleThumbnailCrop::ComputeTargetSizeAtMaximumScale(target_size_);
 
   SkBitmap source_bitmap =
       PrepareSourceBitmap(bitmap, target_thumbnail_size, context.get());
 
   // If the source is same (or smaller) than the target, just return it as
   // the final result. Otherwise, send the shrinking task to the blocking
   // thread pool.
   if (source_bitmap.width() <= target_thumbnail_size.width() ||
       source_bitmap.height() <= target_thumbnail_size.height()) {
-    context->score.boring_score =
-        color_utils::CalculateBoringScore(source_bitmap);
-    context->score.good_clipping =
-        (context->clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
-         context->clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
-         context->clip_result == CLIP_RESULT_NOT_CLIPPED ||
-         context->clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET);
+    context->SetBoringScore(color_utils::CalculateBoringScore(source_bitmap));
+    ClipResult clip_result = context->clip_result();
+    bool good_clipping =
+        (clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
+         clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
+         clip_result == CLIP_RESULT_NOT_CLIPPED ||
+         clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET);
+    context->SetGoodClipping(good_clipping);
 
     callback.Run(*context.get(), source_bitmap);
     return;
   }
 
   if (!BrowserThread::GetBlockingPool()->PostWorkerTaskWithShutdownBehavior(
           FROM_HERE,
           base::Bind(&CreateRetargetedThumbnail,
                      source_bitmap,
                      target_thumbnail_size,
                      context,
                      callback),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {
     LOG(WARNING) << "PostSequencedWorkerTask failed. The thumbnail for "
-                 << context->url << " will not be created.";
+                 << context->GetURL() << " will not be created.";
   }
 }
 
 // static
 SkBitmap ContentBasedThumbnailingAlgorithm::PrepareSourceBitmap(
     const SkBitmap& received_bitmap,
     const gfx::Size& thumbnail_size,
     ThumbnailingContext* context) {
   gfx::Size resize_target;
   SkBitmap clipped_bitmap;
-  if (context->clip_result == CLIP_RESULT_UNPROCESSED) {
+  if (context->clip_result() == CLIP_RESULT_UNPROCESSED) {
     // This case will require extracting a fragment from the retrieved bitmap.
     int scrollbar_size = gfx::scrollbar_size();
     gfx::Size scrollbarless(
         std::max(1, received_bitmap.width() - scrollbar_size),
         std::max(1, received_bitmap.height() - scrollbar_size));
 
+    ClipResult clip_result;
     gfx::Rect clipping_rect = GetClippingRect(
         scrollbarless,
         thumbnail_size,
         &resize_target,
-        &context->clip_result);
+        &clip_result);
+    context->set_clip_result(clip_result);
 
     received_bitmap.extractSubset(&clipped_bitmap,
                                   gfx::RectToSkIRect(clipping_rect));
   } else {
     // This means that the source bitmap has been requested and at least
     // clipped. Upstream code in same cases seems opportunistic and it may
     // not perform actual resizing if copying with resize is not supported.
     // In this case we will resize to the orignally requested copy size.
-    resize_target = context->requested_copy_size;
+    resize_target = context->requested_copy_size();
     clipped_bitmap = received_bitmap;
   }
 
   SkBitmap result_bitmap = SkBitmapOperations::DownsampleByTwoUntilSize(
       clipped_bitmap, resize_target.width(), resize_target.height());
 #if !defined(USE_AURA)
   // If the bitmap has not been indeed resized, it has to be copied. In that
   // case resampler simply returns a reference to the original bitmap, sitting
   // in PlatformCanvas. One does not simply assign these 'magic' bitmaps to
   // SkBitmap. They cannot be refcounted.
@@ skipping 10 matching lines @@
 }
 
 // static
 void ContentBasedThumbnailingAlgorithm::CreateRetargetedThumbnail(
     const SkBitmap& source_bitmap,
     const gfx::Size& thumbnail_size,
     scoped_refptr<ThumbnailingContext> context,
     const ConsumerCallback& callback) {
   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
   float kernel_sigma =
-      context->clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET ? 5.0f : 2.5f;
+      context->clip_result() == CLIP_RESULT_SOURCE_SAME_AS_TARGET ? 5.0f : 2.5f;
   SkBitmap thumbnail = thumbnailing_utils::CreateRetargetedThumbnailImage(
       source_bitmap, thumbnail_size, kernel_sigma);
   bool processing_failed = thumbnail.empty();
   if (processing_failed) {
     // Log and apply the method very much like in SimpleThumbnailCrop (except
     // that some clipping and copying is not required).
     LOG(WARNING) << "CreateRetargetedThumbnailImage failed. "
-                 << "The thumbnail for " << context->url
+                 << "The thumbnail for " << context->GetURL()
                  << " will be created the old-fashioned way.";
 
     ClipResult clip_result;
     gfx::Rect clipping_rect = SimpleThumbnailCrop::GetClippingRect(
         gfx::Size(source_bitmap.width(), source_bitmap.height()),
         thumbnail_size,
         &clip_result);
     source_bitmap.extractSubset(&thumbnail, gfx::RectToSkIRect(clipping_rect));
     thumbnail = SkBitmapOperations::DownsampleByTwoUntilSize(
         thumbnail, thumbnail_size.width(), thumbnail_size.height());
   }
 
   if (processing_failed) {
     LOCAL_HISTOGRAM_TIMES(kFailureHistogramName,
                           base::TimeTicks::Now() - begin_compute_thumbnail);
   } else {
     LOCAL_HISTOGRAM_TIMES(kThumbnailHistogramName,
                           base::TimeTicks::Now() - begin_compute_thumbnail);
   }
-  context->score.boring_score =
-      color_utils::CalculateBoringScore(source_bitmap);
-  if (!processing_failed)
-    context->score.boring_score *= kScoreBoostFromSuccessfulRetargeting;
-  context->score.good_clipping =
-      (context->clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
-       context->clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
-       context->clip_result == CLIP_RESULT_NOT_CLIPPED ||
-       context->clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET);
+  double boring_score = color_utils::CalculateBoringScore(source_bitmap);
+  if (!processing_failed) {
+    boring_score *= kScoreBoostFromSuccessfulRetargeting;
+  }
+  context->SetBoringScore(boring_score);
+  ClipResult clip_result = context->clip_result();
+  bool good_clipping =
+      (clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
+       clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
+       clip_result == CLIP_RESULT_NOT_CLIPPED ||
+       clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET);
+   context->SetGoodClipping(good_clipping);
   // Post the result (the bitmap) back to the callback.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CallbackInvocationAdapter, callback, context, thumbnail));
 }
 
 ContentBasedThumbnailingAlgorithm::~ContentBasedThumbnailingAlgorithm() {
 }
 
@@ skipping 24 matching lines @@
   } else {
     clipping_rect = gfx::Rect(source_size);
     target_size->SetSize(source_size.width() / 2, source_size.height() / 2);
     *clip_result = CLIP_RESULT_NOT_CLIPPED;
   }
 
   return clipping_rect;
 }
 
 }  // namespace thumbnails