Fixed the WallpaperResizer to ensure the image isn't destroyed prematurely.

components/wallpaper/wallpaper_resizer.cc

 // Copyright (c) 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 "components/wallpaper/wallpaper_resizer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/task_runner.h"
 #include "components/wallpaper/wallpaper_resizer_observer.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/skia_util.h"
 
 namespace wallpaper {
 namespace {
 
 // For our scaling ratios we need to round positive numbers.
 int RoundPositive(double x) {
   return static_cast<int>(floor(x + 0.5));
 }
 
-// Resizes |orig_bitmap| to |target_size| using |layout| and stores the
+// Resizes |image| to |target_size| using |layout| and stores the
 // resulting bitmap at |resized_bitmap_out|.
-void Resize(SkBitmap orig_bitmap,
+//
+// NOTE: |image| is intentionally a copy to ensure it exists for the duration of
+// the function.
+void Resize(const gfx::ImageSkia image,
             const gfx::Size& target_size,
             WallpaperLayout layout,
             SkBitmap* resized_bitmap_out,
             base::TaskRunner* task_runner) {
   DCHECK(task_runner->RunsTasksOnCurrentThread());
+
+  SkBitmap orig_bitmap = *image.bitmap();
   SkBitmap new_bitmap = orig_bitmap;
 
   const int orig_width = orig_bitmap.width();
   const int orig_height = orig_bitmap.height();
   const int new_width = target_size.width();
   const int new_height = target_size.height();
 
   if (orig_width > new_width || orig_height > new_height) {
     gfx::Rect wallpaper_rect(0, 0, orig_width, orig_height);
     gfx::Size cropped_size = gfx::Size(std::min(new_width, orig_width),
@@ skipping 75 matching lines @@
 
 WallpaperResizer::~WallpaperResizer() {
 }
 
 void WallpaperResizer::StartResize() {
   start_calculation_time_ = base::TimeTicks::Now();
 
   SkBitmap* resized_bitmap = new SkBitmap;
   if (!task_runner_->PostTaskAndReply(
           FROM_HERE,
-          base::Bind(&Resize, *image_.bitmap(), target_size_, layout_,
-                     resized_bitmap, base::RetainedRef(task_runner_)),
+          base::Bind(&Resize, image_, target_size_, layout_, resized_bitmap,
+                     base::RetainedRef(task_runner_)),
           base::Bind(&WallpaperResizer::OnResizeFinished,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Owned(resized_bitmap)))) {
     LOG(WARNING) << "PostSequencedWorkerTask failed. "
                  << "Wallpaper may not be resized.";
   }
 }
 
 void WallpaperResizer::AddObserver(WallpaperResizerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WallpaperResizer::RemoveObserver(WallpaperResizerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WallpaperResizer::OnResizeFinished(SkBitmap* resized_bitmap) {
   image_ = gfx::ImageSkia::CreateFrom1xBitmap(*resized_bitmap);
   UMA_HISTOGRAM_TIMES("Ash.Wallpaper.TimeSpentResizing",
                       base::TimeTicks::Now() - start_calculation_time_);
 
   for (auto& observer : observers_)
     observer.OnWallpaperResized();
 }
 
 }  // namespace wallpaper