Move logic in UserImageScreen from UserImageScreenHandler

R=ygorshenin@chromium.org
BUG=231331
TBR=ben@chromium.org (API usage adjustements in chrome/browser/automation)

Review URL: https://chromiumcodereview.appspot.com/14063017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@194917 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/automation/testing_automation_provider_chromeos.cc

@@ -390,10 +390,13 @@ void TestingAutomationProvider::PickUserImage(DictionaryValue* args,
   WizardControllerObserver* observer =
       new WizardControllerObserver(wizard_controller, this, reply_message);
   if (image_type == "profile") {
-    image_screen->OnProfileImageSelected();
+    image_screen->OnImageSelected("", image_type);
+    image_screen->OnImageAccepted();
   } else if (image_type.empty() && image_number >= 0 &&
              image_number < chromeos::kDefaultImagesCount) {
-    image_screen->OnDefaultImageSelected(image_number);
+    image_screen->OnImageSelected(
+        chromeos::GetDefaultImageUrl(image_number), image_type);
+    image_screen->OnImageAccepted();
   } else {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args.");

chrome/browser/chromeos/login/screens/user_image_screen.cc

@@ -7,6 +7,7 @@
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_util.h"
+#include "chrome/browser/chromeos/camera_detector.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
@@ -15,6 +16,8 @@
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/url_constants.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ -22,6 +25,9 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/webui/web_ui_util.h"
+
+using content::BrowserThread;
 
 namespace chromeos {
 
@@ -36,7 +42,12 @@ UserImageScreen::UserImageScreen(ScreenObserver* screen_observer,
                                  UserImageScreenActor* actor)
     : WizardScreen(screen_observer),
       actor_(actor),
-      profile_picture_enabled_(false) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      accept_photo_after_decoding_(false),
+      selected_image_(User::kInvalidImageIndex),
+      profile_picture_enabled_(false),
+      profile_picture_data_url_(chrome::kAboutBlankURL),
+      profile_picture_absent_(false) {
   actor_->SetDelegate(this);
   SetProfilePictureEnabled(true);
 }
@@ -44,8 +55,97 @@ UserImageScreen::UserImageScreen(ScreenObserver* screen_observer,
 UserImageScreen::~UserImageScreen() {
   if (actor_)
     actor_->SetDelegate(NULL);
+  if (image_decoder_.get())
+    image_decoder_->set_delegate(NULL);
+}
+
+void UserImageScreen::CheckCameraPresence() {
+  CameraDetector::StartPresenceCheck(
+      base::Bind(&UserImageScreen::OnCameraPresenceCheckDone,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void UserImageScreen::OnCameraPresenceCheckDone() {
+  if (actor_) {
+    actor_->SetCameraPresent(
+        CameraDetector::camera_presence() == CameraDetector::kCameraPresent);
+  }
+}
+
+void UserImageScreen::OnPhotoTaken(const std::string& raw_data) {
+  DCHECK(BrowserThread::CurrentlyOn(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 =
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
+  image_decoder_->Start(task_runner);
 }
 
+void UserImageScreen::OnImageDecoded(const ImageDecoder* decoder,
+                                     const SkBitmap& decoded_image) {
+  DCHECK_EQ(image_decoder_.get(), decoder);
+  user_photo_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
+  if (accept_photo_after_decoding_)
+    OnImageAccepted();
+}
+
+void UserImageScreen::OnDecodeImageFailed(const ImageDecoder* decoder) {
+  NOTREACHED() << "Failed to decode PNG image from WebUI";
+}
+
+void UserImageScreen::OnImageSelected(const std::string& image_type,
+                                      const std::string& image_url) {
+  if (image_url.empty())
+    return;
+  int user_image_index = User::kInvalidImageIndex;
+  if (image_type == "default" &&
+      IsDefaultImageUrl(image_url, &user_image_index)) {
+    selected_image_ = user_image_index;
+  } else if (image_type == "camera") {
+    selected_image_ = User::kExternalImageIndex;
+  } else if (image_type == "profile") {
+    selected_image_ = User::kProfileImageIndex;
+  } else {
+    NOTREACHED() << "Unexpected image type: " << image_type;
+  }
+}
+
+void UserImageScreen::OnImageAccepted() {
+  UserManager* user_manager = UserManager::Get();
+  UserImageManager* image_manager = user_manager->GetUserImageManager();
+  std::string user_id = GetUser()->email();
+  int uma_index = 0;
+  switch (selected_image_) {
+    case User::kExternalImageIndex:
+      // Photo decoding may not have been finished yet.
+      if (user_photo_.isNull()) {
+        accept_photo_after_decoding_ = true;
+        return;
+      }
+      image_manager->
+          SaveUserImage(user_id, UserImage::CreateAndEncode(user_photo_));
+      uma_index = kHistogramImageFromCamera;
+      break;
+    case User::kProfileImageIndex:
+      image_manager->SaveUserImageFromProfileImage(user_id);
+      uma_index = kHistogramImageFromProfile;
+      break;
+    default:
+      DCHECK(selected_image_ >= 0 && selected_image_ < kDefaultImagesCount);
+      image_manager->SaveUserDefaultImageIndex(user_id, selected_image_);
+      uma_index = GetDefaultImageHistogramValue(selected_image_);
+      break;
+  }
+  UMA_HISTOGRAM_ENUMERATION("UserImage.FirstTimeChoice",
+                            uma_index,
+                            kHistogramImagesCount);
+  get_screen_observer()->OnExit(ScreenObserver::USER_IMAGE_SELECTED);
+}
+
+
 void UserImageScreen::SetProfilePictureEnabled(bool profile_picture_enabled) {
   if (profile_picture_enabled_ == profile_picture_enabled)
     return;
@@ -90,7 +190,8 @@ void UserImageScreen::Show() {
   actor_->Show();
   actor_->SetProfilePictureEnabled(profile_picture_enabled_);
 
-  actor_->SelectImage(GetUser()->image_index());
+  selected_image_ = GetUser()->image_index();
+  actor_->SelectImage(selected_image_);
 
   if (profile_picture_enabled_) {
     // Start fetching the profile image.
@@ -111,43 +212,6 @@ std::string UserImageScreen::GetName() const {
   return WizardController::kUserImageScreenName;
 }
 
-void UserImageScreen::OnPhotoTaken(const gfx::ImageSkia& image) {
-  UserManager* user_manager = UserManager::Get();
-  user_manager->GetUserImageManager()->SaveUserImage(
-      GetUser()->email(),
-      UserImage::CreateAndEncode(image));
-
-  get_screen_observer()->OnExit(ScreenObserver::USER_IMAGE_SELECTED);
-
-  UMA_HISTOGRAM_ENUMERATION("UserImage.FirstTimeChoice",
-                            kHistogramImageFromCamera,
-                            kHistogramImagesCount);
-}
-
-void UserImageScreen::OnProfileImageSelected() {
-  UserManager* user_manager = UserManager::Get();
-  user_manager->GetUserImageManager()->SaveUserImageFromProfileImage(
-      GetUser()->email());
-
-  get_screen_observer()->OnExit(ScreenObserver::USER_IMAGE_SELECTED);
-
-  UMA_HISTOGRAM_ENUMERATION("UserImage.FirstTimeChoice",
-                            kHistogramImageFromProfile,
-                            kHistogramImagesCount);
-}
-
-void UserImageScreen::OnDefaultImageSelected(int index) {
-  UserManager* user_manager = UserManager::Get();
-  user_manager->GetUserImageManager()->SaveUserDefaultImageIndex(
-      GetUser()->email(), index);
-
-  get_screen_observer()->OnExit(ScreenObserver::USER_IMAGE_SELECTED);
-
-  UMA_HISTOGRAM_ENUMERATION("UserImage.FirstTimeChoice",
-                            GetDefaultImageHistogramValue(index),
-                            kHistogramImagesCount);
-}
-
 void UserImageScreen::OnActorDestroyed(UserImageScreenActor* actor) {
   if (actor_ == actor)
     actor_ = NULL;
@@ -160,14 +224,15 @@ void UserImageScreen::Observe(int type,
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED: {
       // We've got a new profile image.
-      if (actor_) {
-        actor_->AddProfileImage(
-            *content::Details<const gfx::ImageSkia>(details).ptr());
-      }
+      profile_picture_data_url_ = webui::GetBitmapDataUrl(
+          *content::Details<const gfx::ImageSkia>(details).ptr()->bitmap());
+      if (actor_)
+        actor_->SendProfileImage(profile_picture_data_url_);
       break;
     }
     case chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED: {
       // User has a default profile image or fetching profile image has failed.
+      profile_picture_absent_ = true;
       if (actor_)
         actor_->OnProfileImageAbsent();
       break;
@@ -177,4 +242,16 @@ void UserImageScreen::Observe(int type,
   }
 }
 
+bool UserImageScreen::profile_picture_absent() {
+  return profile_picture_absent_;
+}
+
+int UserImageScreen::selected_image() {
+  return selected_image_;
+}
+
+std::string UserImageScreen::profile_picture_data_url() {
+  return profile_picture_data_url_;
+}
+
 }  // namespace chromeos

chrome/browser/chromeos/login/screens/user_image_screen.h

@@ -6,9 +6,11 @@
 #define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_IMAGE_SCREEN_H_
 
 #include "base/compiler_specific.h"
+#include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/login/screens/user_image_screen_actor.h"
 #include "chrome/browser/chromeos/login/screens/wizard_screen.h"
 #include "chrome/browser/chromeos/login/user.h"
+#include "chrome/browser/image_decoder.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
@@ -16,6 +18,7 @@ namespace chromeos {
 
 class UserImageScreen: public WizardScreen,
                        public UserImageScreenActor::Delegate,
+                       public ImageDecoder::Delegate,
                        public content::NotificationObserver {
  public:
   UserImageScreen(ScreenObserver* screen_observer,
@@ -34,25 +37,62 @@ class UserImageScreen: public WizardScreen,
   virtual std::string GetName() const OVERRIDE;
 
   // UserImageScreenActor::Delegate implementation:
-  virtual void OnPhotoTaken(const gfx::ImageSkia& image) OVERRIDE;
-  virtual void OnProfileImageSelected() OVERRIDE;
-  virtual void OnDefaultImageSelected(int index) OVERRIDE;
+  virtual void CheckCameraPresence() OVERRIDE;
+  virtual void OnPhotoTaken(const std::string& raw_data) OVERRIDE;
+  virtual void OnImageSelected(const std::string& image_url,
+                               const std::string& image_type) OVERRIDE;
+  virtual void OnImageAccepted() OVERRIDE;
   virtual void OnActorDestroyed(UserImageScreenActor* actor) OVERRIDE;
 
+  virtual bool profile_picture_absent() OVERRIDE;
+  virtual int selected_image() OVERRIDE;
+  virtual std::string profile_picture_data_url() OVERRIDE;
+
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // Overriden from ImageDecoder::Delegate:
+  virtual void OnImageDecoded(const ImageDecoder* decoder,
+                              const SkBitmap& decoded_image) OVERRIDE;
+  virtual void OnDecodeImageFailed(const ImageDecoder* decoder) OVERRIDE;
+
  private:
   const User* GetUser();
 
+  // Called when the camera presence check has been completed.
+  void OnCameraPresenceCheckDone();
+
   content::NotificationRegistrar registrar_;
 
   UserImageScreenActor* actor_;
 
+  base::WeakPtrFactory<UserImageScreen> weak_factory_;
+
+  // Last ImageDecoder instance used to decode an image blob received by
+  // HandlePhotoTaken.
+  scoped_refptr<ImageDecoder> image_decoder_;
+
+  // Last user photo, if taken.
+  gfx::ImageSkia user_photo_;
+
+  // If |true|, decoded photo should be immediately accepeted (i.e., both
+  // HandleTakePhoto and HandleImageAccepted have already been called but we're
+  // still waiting for  photo image decoding to finish.
+  bool accept_photo_after_decoding_;
+
+  // Index of the selected user image.
+  int selected_image_;
+
   bool profile_picture_enabled_;
 
+  // Encoded profile picture.
+  std::string profile_picture_data_url_;
+
+  // True if user has no custom profile picture.
+  bool profile_picture_absent_;
+
   std::string user_id_;
 
   DISALLOW_COPY_AND_ASSIGN(UserImageScreen);

chrome/browser/chromeos/login/screens/user_image_screen_actor.h

@@ -5,6 +5,8 @@
 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_IMAGE_SCREEN_ACTOR_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_IMAGE_SCREEN_ACTOR_H_
 
+#include <string>
+
 class SkBitmap;
 
 namespace gfx {
@@ -22,14 +24,22 @@ class UserImageScreenActor {
     virtual ~Delegate() {}
 
     // Called when user accepts photo as login user image.
-    virtual void OnPhotoTaken(const gfx::ImageSkia& image) = 0;
-    // Called when user accepts Profile image as login user image.
-    virtual void OnProfileImageSelected() = 0;
-    // Called when user accepts one of the default images as login user
-    // image.
-    virtual void OnDefaultImageSelected(int index) = 0;
+    virtual void OnPhotoTaken(const std::string& raw_data) = 0;
+    // Called to check camera presence.
+    virtual void CheckCameraPresence() = 0;
+    // Called when user selects some image
+    virtual void OnImageSelected(const std::string& image_url,
+                                 const std::string& image_type) = 0;
+    // Called when user accepts currently selected image
+    virtual void OnImageAccepted() = 0;
+
     // Called when actor is destroyed so there's no dead reference to it.
     virtual void OnActorDestroyed(UserImageScreenActor* actor) = 0;
+
+    virtual bool profile_picture_absent() = 0;
+    virtual int selected_image() = 0;
+    virtual std::string profile_picture_data_url() = 0;
+
   };
 
   virtual ~UserImageScreenActor() {}
@@ -49,17 +59,17 @@ class UserImageScreenActor {
   // Selects image with the index specified.
   virtual void SelectImage(int index) = 0;
 
-  // Starts camera presence check.
-  virtual void CheckCameraPresence() = 0;
+  // Sends profile image as a data URL to the page.
+  virtual void SendProfileImage(const std::string& data_url) = 0;
+
+  // Indicates that there is no custom profile image for the user.
+  virtual void OnProfileImageAbsent() = 0;
 
   // Enables or disables profile picture.
   virtual void SetProfilePictureEnabled(bool enabled) = 0;
 
-  // Inserts profile image in the list for user to select.
-  virtual void AddProfileImage(const gfx::ImageSkia& image) {}
-
-  // Indicates that there is no custom profile image for the user.
-  virtual void OnProfileImageAbsent() {}
+  // Sends result of camera check
+  virtual void SetCameraPresent(bool enabled) = 0;
 };
 
 }  // namespace chromeos

chrome/browser/ui/webui/chromeos/login/user_image_screen_handler.cc

@@ -8,63 +8,27 @@
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/camera_detector.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
-#include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/data_url.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/views/widget/widget.h"
-#include "ui/webui/web_ui_util.h"
-
-using content::BrowserThread;
 
 namespace chromeos {
 
 UserImageScreenHandler::UserImageScreenHandler()
     : screen_(NULL),
-      show_on_init_(false),
-      selected_image_(User::kInvalidImageIndex),
-      accept_photo_after_decoding_(false),
-      user_photo_data_url_(chrome::kAboutBlankURL),
-      profile_picture_data_url_(chrome::kAboutBlankURL),
-      profile_picture_absent_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+      show_on_init_(false) {
 }
 
 UserImageScreenHandler::~UserImageScreenHandler() {
   if (screen_)
     screen_->OnActorDestroyed(this);
-  if (image_decoder_.get())
-    image_decoder_->set_delegate(NULL);
-}
-
-void UserImageScreenHandler::DeclareLocalizedValues(
-    LocalizedValuesBuilder* builder) {
-  // TODO(ivankr): string should be renamed to something like
-  // IDS_USER_IMAGE_SCREEN_TITLE (currently used for Take Photo dialog).
-  builder->Add("userImageScreenTitle", IDS_OOBE_PICTURE);
-  builder->Add("userImageScreenDescription",
-               IDS_OPTIONS_CHANGE_PICTURE_DIALOG_TEXT);
-  builder->Add("takePhoto", IDS_OPTIONS_CHANGE_PICTURE_TAKE_PHOTO);
-  builder->Add("discardPhoto", IDS_OPTIONS_CHANGE_PICTURE_DISCARD_PHOTO);
-  builder->Add("flipPhoto", IDS_OPTIONS_CHANGE_PICTURE_FLIP_PHOTO);
-  builder->Add("profilePhoto", IDS_IMAGE_SCREEN_PROFILE_PHOTO);
-  builder->Add("profilePhotoLoading",
-               IDS_IMAGE_SCREEN_PROFILE_LOADING_PHOTO);
-  builder->Add("okButtonText", IDS_OK);
-  builder->Add("authorCredit", IDS_OPTIONS_SET_WALLPAPER_AUTHOR_TEXT);
-  builder->Add("photoFromCamera", IDS_OPTIONS_CHANGE_PICTURE_PHOTO_FROM_CAMERA);
-  builder->Add("photoCaptureAccessibleText",
-               IDS_OPTIONS_PHOTO_CAPTURE_ACCESSIBLE_TEXT);
-  builder->Add("photoDiscardAccessibleText",
-               IDS_OPTIONS_PHOTO_DISCARD_ACCESSIBLE_TEXT);
 }
 
 void UserImageScreenHandler::Initialize() {
@@ -88,7 +52,9 @@ void UserImageScreenHandler::Show() {
   ShowScreen(OobeUI::kScreenUserImagePicker, NULL);
 
   // When shown, query camera presence.
-  CheckCameraPresence();
+  if (!screen_)
+    return;
+  screen_->CheckCameraPresence();
 }
 
 void UserImageScreenHandler::Hide() {
@@ -97,16 +63,26 @@ void UserImageScreenHandler::Hide() {
 void UserImageScreenHandler::PrepareToShow() {
 }
 
-void UserImageScreenHandler::SelectImage(int index) {
-  selected_image_ = index;
-  if (page_is_ready())
-    CallJS("oobe.UserImageScreen.setSelectedImage", GetDefaultImageUrl(index));
-}
-
-void UserImageScreenHandler::CheckCameraPresence() {
-  CameraDetector::StartPresenceCheck(
-      base::Bind(&UserImageScreenHandler::OnCameraPresenceCheckDone,
-                 weak_factory_.GetWeakPtr()));
+void UserImageScreenHandler::DeclareLocalizedValues(
+    LocalizedValuesBuilder* builder) {
+  // TODO(ivankr): string should be renamed to something like
+  // IDS_USER_IMAGE_SCREEN_TITLE (currently used for Take Photo dialog).
+  builder->Add("userImageScreenTitle", IDS_OOBE_PICTURE);
+  builder->Add("userImageScreenDescription",
+               IDS_OPTIONS_CHANGE_PICTURE_DIALOG_TEXT);
+  builder->Add("takePhoto", IDS_OPTIONS_CHANGE_PICTURE_TAKE_PHOTO);
+  builder->Add("discardPhoto", IDS_OPTIONS_CHANGE_PICTURE_DISCARD_PHOTO);
+  builder->Add("flipPhoto", IDS_OPTIONS_CHANGE_PICTURE_FLIP_PHOTO);
+  builder->Add("profilePhoto", IDS_IMAGE_SCREEN_PROFILE_PHOTO);
+  builder->Add("profilePhotoLoading",
+               IDS_IMAGE_SCREEN_PROFILE_LOADING_PHOTO);
+  builder->Add("okButtonText", IDS_OK);
+  builder->Add("authorCredit", IDS_OPTIONS_SET_WALLPAPER_AUTHOR_TEXT);
+  builder->Add("photoFromCamera", IDS_OPTIONS_CHANGE_PICTURE_PHOTO_FROM_CAMERA);
+  builder->Add("photoCaptureAccessibleText",
+               IDS_OPTIONS_PHOTO_CAPTURE_ACCESSIBLE_TEXT);
+  builder->Add("photoDiscardAccessibleText",
+               IDS_OPTIONS_PHOTO_DISCARD_ACCESSIBLE_TEXT);
 }
 
 void UserImageScreenHandler::RegisterMessages() {
@@ -121,9 +97,9 @@ void UserImageScreenHandler::RegisterMessages() {
               &UserImageScreenHandler::HandleScreenShown);
 }
 
-void UserImageScreenHandler::AddProfileImage(const gfx::ImageSkia& image) {
-  profile_picture_data_url_ = webui::GetBitmapDataUrl(*image.bitmap());
-  SendProfileImage(profile_picture_data_url_);
+void UserImageScreenHandler::SelectImage(int index) {
+  if (page_is_ready())
+    CallJS("oobe.UserImageScreen.setSelectedImage", GetDefaultImageUrl(index));
 }
 
 void UserImageScreenHandler::SendProfileImage(const std::string& data_url) {
@@ -132,13 +108,13 @@ void UserImageScreenHandler::SendProfileImage(const std::string& data_url) {
 }
 
 void UserImageScreenHandler::OnProfileImageAbsent() {
-  profile_picture_absent_ = true;
   if (page_is_ready()) {
     scoped_ptr<base::Value> null_value(base::Value::CreateNullValue());
     CallJS("oobe.UserImageScreen.setProfileImage", *null_value);
   }
 }
 
+// TODO(antrim) : It looks more like parameters for "Init" rather than callback.
 void UserImageScreenHandler::HandleGetImages() {
   base::ListValue image_urls;
   for (int i = kFirstDefaultImageIndex; i < kDefaultImagesCount; ++i) {
@@ -152,77 +128,42 @@ void UserImageScreenHandler::HandleGetImages() {
     image_urls.Append(image_data.release());
   }
   CallJS("oobe.UserImageScreen.setDefaultImages", image_urls);
+  if (!screen_)
+    return;
+  if (screen_->selected_image() != User::kInvalidImageIndex)
+    SelectImage(screen_->selected_image());
 
-  if (selected_image_ != User::kInvalidImageIndex)
-    SelectImage(selected_image_);
-
-  if (profile_picture_data_url_ != chrome::kAboutBlankURL)
-    SendProfileImage(profile_picture_data_url_);
-  else if (profile_picture_absent_)
+  if (screen_->profile_picture_data_url() != chrome::kAboutBlankURL)
+    SendProfileImage(screen_->profile_picture_data_url());
+  else if (screen_->profile_picture_absent())
     OnProfileImageAbsent();
 }
 
 void UserImageScreenHandler::HandlePhotoTaken(const std::string& image_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string mime_type, charset, raw_data;
   if (!net::DataURL::Parse(GURL(image_url), &mime_type, &charset, &raw_data))
     NOTREACHED();
   DCHECK_EQ("image/png", mime_type);
 
-  user_photo_ = gfx::ImageSkia();
-  user_photo_data_url_ = image_url;
-
-  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 =
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
-  image_decoder_->Start(task_runner);
+  if (screen_)
+    screen_->OnPhotoTaken(raw_data);
 }
 
 void UserImageScreenHandler::HandleCheckCameraPresence() {
-  CheckCameraPresence();
+  if (!screen_)
+    return;
+  screen_->CheckCameraPresence();
 }
 
 void UserImageScreenHandler::HandleSelectImage(const std::string& image_url,
                                                const std::string& image_type) {
-  if (image_url.empty())
-    return;
-
-  int user_image_index = User::kInvalidImageIndex;
-  if (image_type == "default" &&
-      IsDefaultImageUrl(image_url, &user_image_index)) {
-    selected_image_ = user_image_index;
-  } else if (image_type == "camera") {
-    selected_image_ = User::kExternalImageIndex;
-  } else if (image_type == "profile") {
-    selected_image_ = User::kProfileImageIndex;
-  } else {
-    NOTREACHED() << "Unexpected image type: " << image_type;
-  }
+  if (screen_)
+    screen_->OnImageSelected(image_type, image_url);
 }
 
 void UserImageScreenHandler::HandleImageAccepted() {
-  if (!screen_)
-    return;
-  switch (selected_image_) {
-    case User::kExternalImageIndex:
-      // Photo decoding may not have been finished yet.
-      if (user_photo_.isNull())
-        accept_photo_after_decoding_ = true;
-      else
-        screen_->OnPhotoTaken(user_photo_);
-      break;
-
-    case User::kProfileImageIndex:
-      screen_->OnProfileImageSelected();
-      break;
-
-    default:
-      DCHECK(selected_image_ >= 0 && selected_image_ < kDefaultImagesCount);
-      screen_->OnDefaultImageSelected(selected_image_);
-  }
+  if (screen_)
+    screen_->OnImageAccepted();
 }
 
 void UserImageScreenHandler::HandleScreenShown() {
@@ -233,21 +174,8 @@ void UserImageScreenHandler::HandleScreenShown() {
   UMA_HISTOGRAM_TIMES("UserImage.ScreenIsShownTime", delta);
 }
 
-void UserImageScreenHandler::OnCameraPresenceCheckDone() {
-  CallJS("oobe.UserImageScreen.setCameraPresent",
-         CameraDetector::camera_presence() == CameraDetector::kCameraPresent);
-}
-
-void UserImageScreenHandler::OnImageDecoded(const ImageDecoder* decoder,
-                                            const SkBitmap& decoded_image) {
-  DCHECK_EQ(image_decoder_.get(), decoder);
-  user_photo_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
-  if (screen_ && accept_photo_after_decoding_)
-    screen_->OnPhotoTaken(user_photo_);
-}
-
-void UserImageScreenHandler::OnDecodeImageFailed(const ImageDecoder* decoder) {
-  NOTREACHED() << "Failed to decode PNG image from WebUI";
+void UserImageScreenHandler::SetCameraPresent(bool present) {
+  CallJS("oobe.UserImageScreen.setCameraPresent", present);
 }
 
 void UserImageScreenHandler::SetProfilePictureEnabled(bool enabled) {

chrome/browser/ui/webui/chromeos/login/user_image_screen_handler.h

@@ -10,10 +10,8 @@
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/chromeos/login/screens/user_image_screen_actor.h"
-#include "chrome/browser/image_decoder.h"
 #include "chrome/browser/ui/webui/chromeos/login/base_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
-#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ -22,15 +20,17 @@ namespace chromeos {
 // WebUI implementation of UserImageScreenActor. It is used to interact
 // with JS page part allowing user to select avatar.
 class UserImageScreenHandler : public UserImageScreenActor,
-                               public BaseScreenHandler,
-                               public ImageDecoder::Delegate {
+                               public BaseScreenHandler {
  public:
   UserImageScreenHandler();
   virtual ~UserImageScreenHandler();
 
   // BaseScreenHandler implementation:
-  virtual void DeclareLocalizedValues(LocalizedValuesBuilder* builder) OVERRIDE;
   virtual void Initialize() OVERRIDE;
+  virtual void DeclareLocalizedValues(LocalizedValuesBuilder* builder) OVERRIDE;
+
+  // WebUIMessageHandler implementation:
+  virtual void RegisterMessages() OVERRIDE;
 
   // UserImageScreenActor implementation:
   virtual void SetDelegate(
@@ -38,18 +38,16 @@ class UserImageScreenHandler : public UserImageScreenActor,
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
   virtual void PrepareToShow() OVERRIDE;
+
   virtual void SelectImage(int index) OVERRIDE;
-  virtual void CheckCameraPresence() OVERRIDE;
-  virtual void AddProfileImage(const gfx::ImageSkia& image) OVERRIDE;
+  virtual void SendProfileImage(const std::string& data_url) OVERRIDE;
   virtual void OnProfileImageAbsent() OVERRIDE;
+
   virtual void SetProfilePictureEnabled(bool enabled) OVERRIDE;
 
-  // WebUIMessageHandler implementation:
-  virtual void RegisterMessages() OVERRIDE;
+  virtual void SetCameraPresent(bool enabled) OVERRIDE;
 
  private:
-  // Sends profile image as a data URL to the page.
-  void SendProfileImage(const std::string& data_url);
 
   // Sends image data to the page.
   void HandleGetImages();
@@ -70,46 +68,11 @@ class UserImageScreenHandler : public UserImageScreenActor,
   // Called when the user image screen has been loaded and shown.
   void HandleScreenShown();
 
-  // Called when the camera presence check has been completed.
-  void OnCameraPresenceCheckDone();
-
-  // Overriden from ImageDecoder::Delegate:
-  virtual void OnImageDecoded(const ImageDecoder* decoder,
-                              const SkBitmap& decoded_image) OVERRIDE;
-  virtual void OnDecodeImageFailed(const ImageDecoder* decoder) OVERRIDE;
-
-
   UserImageScreenActor::Delegate* screen_;
 
   // Keeps whether screen should be shown right after initialization.
   bool show_on_init_;
 
-  // Index of the selected user image.
-  int selected_image_;
-
-  // Last user photo, if taken.
-  gfx::ImageSkia user_photo_;
-
-  // Last ImageDecoder instance used to decode an image blob received by
-  // HandlePhotoTaken.
-  scoped_refptr<ImageDecoder> image_decoder_;
-
-  // If |true|, decoded photo should be immediately accepeted (i.e., both
-  // HandleTakePhoto and HandleImageAccepted have already been called but we're
-  // still waiting for  photo image decoding to finish.
-  bool accept_photo_after_decoding_;
-
-  // Data URL for |user_photo_|.
-  std::string user_photo_data_url_;
-
-  // Data URL of the profile picture;
-  std::string profile_picture_data_url_;
-
-  // True if user has no custom profile picture.
-  bool profile_picture_absent_;
-
-  base::WeakPtrFactory<UserImageScreenHandler> weak_factory_;
-
   base::Time screen_show_time_;
 
   DISALLOW_COPY_AND_ASSIGN(UserImageScreenHandler);