Make image_decoder a Leaky LazyInstance

chrome/browser/chromeos/login/supervised/supervised_user_creation_screen.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 "chrome/browser/chromeos/login/supervised/supervised_user_creation_screen.h"
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/rand_util.h"
 #include "base/values.h"
@@ skipping 82 matching lines @@
 SupervisedUserCreationScreen* SupervisedUserCreationScreen::Get(
     ScreenManager* manager) {
   return static_cast<SupervisedUserCreationScreen*>(
       manager->GetScreen(WizardController::kSupervisedUserCreationScreenName));
 }
 
 SupervisedUserCreationScreen::SupervisedUserCreationScreen(
     BaseScreenDelegate* base_screen_delegate,
     SupervisedUserCreationScreenHandler* actor)
     : BaseScreen(base_screen_delegate),
+      ImageDecoder::ImageRequest(

[dcheng, 2015/03/23 11:52:08]

I think you should be able to just say ImageRequest here.

[Theresa, 2015/03/23 17:33:09]

Done.

+          content::BrowserThread::GetMessageLoopProxyForThread(
+              content::BrowserThread::UI)),
       actor_(actor),
       on_error_screen_(false),
       manager_signin_in_progress_(false),
       last_page_(kNameOfIntroScreen),
       sync_service_(NULL),
-      image_decoder_(NULL),
       apply_photo_after_decoding_(false),
       selected_image_(0),
       histogram_helper_(new ErrorScreensHistogramHelper("Supervised")),
       weak_factory_(this) {
   DCHECK(actor_);
   if (actor_)
     actor_->SetDelegate(this);
 }
 
 SupervisedUserCreationScreen::~SupervisedUserCreationScreen() {
   CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
   if (sync_service_)
     sync_service_->RemoveObserver(this);
   if (actor_)
     actor_->SetDelegate(NULL);
-  if (image_decoder_.get())
-    image_decoder_->set_delegate(NULL);
   NetworkPortalDetector::Get()->RemoveObserver(this);
 }
 
 void SupervisedUserCreationScreen::PrepareToShow() {
   if (actor_)
     actor_->PrepareToShow();
 }
 
 void SupervisedUserCreationScreen::Show() {
   CameraPresenceNotifier::GetInstance()->AddObserver(this);
@@ skipping 449 matching lines @@
     existing_users_->Set(it.key(), local_copy);
     ui_users->Append(ui_copy);
   }
   actor_->ShowExistingSupervisedUsers(ui_users.get());
 }
 
 void SupervisedUserCreationScreen::OnPhotoTaken(
     const std::string& raw_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   user_photo_ = gfx::ImageSkia();
-  if (image_decoder_.get())
-    image_decoder_->set_delegate(NULL);
-  image_decoder_ = new ImageDecoder(this, raw_data,
-                                    ImageDecoder::DEFAULT_CODEC);
-  scoped_refptr<base::MessageLoopProxy> task_runner =
-      content::BrowserThread::GetMessageLoopProxyForThread(
-          content::BrowserThread::UI);
-  image_decoder_->Start(task_runner);
+  ImageDecoder::Cancel(this);
+  ImageDecoder::Start(this, raw_data, ImageDecoder::DEFAULT_CODEC, false);
 }
 
 void SupervisedUserCreationScreen::OnImageDecoded(
-    const ImageDecoder* decoder,
     const SkBitmap& decoded_image) {
-  DCHECK_EQ(image_decoder_.get(), decoder);
   user_photo_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
   if (apply_photo_after_decoding_)
     ApplyPicture();
 }
 
-void SupervisedUserCreationScreen::OnDecodeImageFailed(
-    const ImageDecoder* decoder) {
+void SupervisedUserCreationScreen::OnDecodeImageFailed() {
   NOTREACHED() << "Failed to decode PNG image from WebUI";
 }
 
 void SupervisedUserCreationScreen::OnImageSelected(
     const std::string& image_type,
     const std::string& image_url) {
   if (image_url.empty())
     return;
   int user_image_index = user_manager::User::USER_IMAGE_INVALID;
   if (image_type == "default" &&
       user_manager::IsDefaultImageUrl(image_url, &user_image_index)) {
     selected_image_ = user_image_index;
   } else if (image_type == "camera") {
     selected_image_ = user_manager::User::USER_IMAGE_EXTERNAL;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
 void SupervisedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos