Settings People Revamp: Implement parts of ChromeOS Change Picture

chrome/browser/ui/webui/settings/chromeos/change_picture_handler.cc

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// 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 "chrome/browser/ui/webui/options/chromeos/change_picture_options_handler.h"
+#include "chrome/browser/ui/webui/settings/chromeos/change_picture_handler.h"
 
 #include "ash/audio/sounds.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 22 matching lines @@
 #include "net/base/data_url.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/views/widget/widget.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
-namespace options {
+namespace settings {
 
 namespace {
 
 // Returns info about extensions for files we support as user images.
 ui::SelectFileDialog::FileTypeInfo GetUserImageFileTypeInfo() {
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
 
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("bmp"));
 
@@ skipping 10 matching lines @@
       l10n_util::GetStringUTF16(IDS_IMAGE_FILES);
 
   return file_type_info;
 }
 
 // Time histogram suffix for profile image download.
 const char kProfileDownloadReason[] = "Preferences";
 
 }  // namespace
 
-ChangePictureOptionsHandler::ChangePictureOptionsHandler()
+ChangePictureHandler::ChangePictureHandler()
     : previous_image_url_(url::kAboutBlankURL),
-      previous_image_index_(user_manager::User::USER_IMAGE_INVALID) {
+      previous_image_index_(user_manager::User::USER_IMAGE_INVALID),
+      camera_observer_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
       content::NotificationService::AllSources());
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   media::SoundsManager* manager = media::SoundsManager::Get();
   manager->Initialize(SOUND_OBJECT_DELETE,
                       bundle.GetRawDataResource(IDR_SOUND_OBJECT_DELETE_WAV));
   manager->Initialize(SOUND_CAMERA_SNAP,
                       bundle.GetRawDataResource(IDR_SOUND_CAMERA_SNAP_WAV));
 }
 
-ChangePictureOptionsHandler::~ChangePictureOptionsHandler() {
-  CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
+ChangePictureHandler::~ChangePictureHandler() {
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 }
 
-void ChangePictureOptionsHandler::GetLocalizedValues(
-    base::DictionaryValue* localized_strings) {
-  DCHECK(localized_strings);
-  localized_strings->SetString("changePicturePage",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_DIALOG_TITLE));
-  localized_strings->SetString("changePicturePageDescription",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_DIALOG_TEXT));
-  localized_strings->SetString("takePhoto",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_TAKE_PHOTO));
-  localized_strings->SetString("discardPhoto",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_DISCARD_PHOTO));
-  localized_strings->SetString("flipPhoto",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_FLIP_PHOTO));
-  localized_strings->SetString("chooseFile",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_CHOOSE_FILE));
-  localized_strings->SetString("profilePhoto",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_PROFILE_PHOTO));
-  localized_strings->SetString("profilePhotoLoading",
-      l10n_util::GetStringUTF16(
-          IDS_OPTIONS_CHANGE_PICTURE_PROFILE_LOADING_PHOTO));
-  localized_strings->SetString("previewAltText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_PREVIEW_ALT));
-  localized_strings->SetString("authorCredit",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_SET_WALLPAPER_AUTHOR_TEXT));
-  localized_strings->SetString("photoFromCamera",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_CHANGE_PICTURE_PHOTO_FROM_CAMERA));
-  localized_strings->SetString("photoFlippedAccessibleText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_PHOTO_FLIP_ACCESSIBLE_TEXT));
-  localized_strings->SetString("photoFlippedBackAccessibleText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_PHOTO_FLIPBACK_ACCESSIBLE_TEXT));
-  localized_strings->SetString("photoCaptureAccessibleText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_PHOTO_CAPTURE_ACCESSIBLE_TEXT));
-  localized_strings->SetString("photoDiscardAccessibleText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_PHOTO_DISCARD_ACCESSIBLE_TEXT));
-}
-
-void ChangePictureOptionsHandler::RegisterMessages() {
+void ChangePictureHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("chooseFile",
-      base::Bind(&ChangePictureOptionsHandler::HandleChooseFile,
+      base::Bind(&ChangePictureHandler::HandleChooseFile,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("takePhoto",
-      base::Bind(&ChangePictureOptionsHandler::HandleTakePhoto,
+      base::Bind(&ChangePictureHandler::HandleTakePhoto,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("photoTaken",
-      base::Bind(&ChangePictureOptionsHandler::HandlePhotoTaken,
+      base::Bind(&ChangePictureHandler::HandlePhotoTaken,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("discardPhoto",
-      base::Bind(&ChangePictureOptionsHandler::HandleDiscardPhoto,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("onChangePicturePageShown",
-      base::Bind(&ChangePictureOptionsHandler::HandlePageShown,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("onChangePicturePageHidden",
-      base::Bind(&ChangePictureOptionsHandler::HandlePageHidden,
+      base::Bind(&ChangePictureHandler::HandleDiscardPhoto,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("onChangePicturePageInitialized",
-      base::Bind(&ChangePictureOptionsHandler::HandlePageInitialized,
+      base::Bind(&ChangePictureHandler::HandlePageInitialized,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("selectImage",
-      base::Bind(&ChangePictureOptionsHandler::HandleSelectImage,
+      base::Bind(&ChangePictureHandler::HandleSelectImage,
                  base::Unretained(this)));
 }
 
-void ChangePictureOptionsHandler::SendDefaultImages() {
+void ChangePictureHandler::SendDefaultImages() {
   base::ListValue image_urls;
   for (int i = user_manager::kFirstDefaultImageIndex;
        i < user_manager::kDefaultImagesCount;
        ++i) {
     scoped_ptr<base::DictionaryValue> image_data(new base::DictionaryValue);
     image_data->SetString("url", user_manager::GetDefaultImageUrl(i));
     image_data->SetString(
         "author",
         l10n_util::GetStringUTF16(user_manager::kDefaultImageAuthorIDs[i]));
     image_data->SetString(
         "website",
         l10n_util::GetStringUTF16(user_manager::kDefaultImageWebsiteIDs[i]));
     image_data->SetString("title", user_manager::GetDefaultImageDescription(i));
     image_urls.Append(image_data.release());
   }
-  web_ui()->CallJavascriptFunction("ChangePictureOptions.setDefaultImages",
-                                   image_urls);
+  web_ui()->CallJavascriptFunction(
+      "settings.ChangePicturePrivateApi.receiveDefaultImages",
+      image_urls);
 }
 
-void ChangePictureOptionsHandler::HandleChooseFile(
+void ChangePictureHandler::HandleChooseFile(
     const base::ListValue* args) {
   DCHECK(args && args->empty());
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
 
   base::FilePath downloads_path;
   if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &downloads_path)) {
     NOTREACHED();
     return;
   }
 
   // Static so we initialize it only once.
   CR_DEFINE_STATIC_LOCAL(ui::SelectFileDialog::FileTypeInfo, file_type_info,
       (GetUserImageFileTypeInfo()));
 
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_OPEN_FILE,
       l10n_util::GetStringUTF16(IDS_DOWNLOAD_TITLE),
       downloads_path,
       &file_type_info,
       0,
       FILE_PATH_LITERAL(""),
       GetBrowserWindow(),
       NULL);
 }
 
-void ChangePictureOptionsHandler::HandleTakePhoto(
+void ChangePictureHandler::HandleTakePhoto(
     const base::ListValue* args) {
   DCHECK(args->empty());
   ash::PlaySystemSoundIfSpokenFeedback(SOUND_CAMERA_SNAP);
 }
 
-void ChangePictureOptionsHandler::HandleDiscardPhoto(
+void ChangePictureHandler::HandleDiscardPhoto(
     const base::ListValue* args) {
   DCHECK(args->empty());
   ash::PlaySystemSoundIfSpokenFeedback(SOUND_OBJECT_DELETE);
 }
 
-void ChangePictureOptionsHandler::HandlePhotoTaken(
+void ChangePictureHandler::HandlePhotoTaken(
     const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string image_url;
   if (!args || args->GetSize() != 1 || !args->GetString(0, &image_url))
     NOTREACHED();
   DCHECK(!image_url.empty());
 
   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;
 
   ImageDecoder::Cancel(this);
   ImageDecoder::Start(this, raw_data);
 }
 
-void ChangePictureOptionsHandler::HandlePageInitialized(
+void ChangePictureHandler::HandlePageInitialized(
     const base::ListValue* args) {
   DCHECK(args && args->empty());
+
+  CameraPresenceNotifier* camera = CameraPresenceNotifier::GetInstance();
+  if (!camera_observer_.IsObserving(camera))
+    camera_observer_.Add(camera);
+
   SendDefaultImages();
+  SendSelectedImage();
+  UpdateProfileImage();
 }
 
-void ChangePictureOptionsHandler::HandlePageShown(const base::ListValue* args) {
-  DCHECK(args && args->empty());
-  SendSelectedImage();
-  UpdateProfileImage();
-  CameraPresenceNotifier::GetInstance()->AddObserver(this);
-}
-
-void ChangePictureOptionsHandler::HandlePageHidden(
-    const base::ListValue* args) {
-  CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
-}
-
-void ChangePictureOptionsHandler::SendSelectedImage() {
+void ChangePictureHandler::SendSelectedImage() {
   const user_manager::User* user = GetUser();
   DCHECK(!user->email().empty());
 
   previous_image_index_ = user->image_index();
   switch (previous_image_index_) {
     case user_manager::User::USER_IMAGE_EXTERNAL: {
       // User has image from camera/file, record it and add to the image list.
       previous_image_ = user->GetImage();
       SendOldImage(webui::GetBitmapDataUrl(*previous_image_.bitmap()));
       break;
     }
     case user_manager::User::USER_IMAGE_PROFILE: {
       // User has his/her Profile image as the current image.
       SendProfileImage(user->GetImage(), true);
       break;
     }
     default: {
       DCHECK(previous_image_index_ >= 0 &&
              previous_image_index_ < user_manager::kDefaultImagesCount);
       if (previous_image_index_ >= user_manager::kFirstDefaultImageIndex) {
         // User has image from the current set of default images.
         base::StringValue image_url(
             user_manager::GetDefaultImageUrl(previous_image_index_));
         web_ui()->CallJavascriptFunction(
-            "ChangePictureOptions.setSelectedImage", image_url);
+            "settings.ChangePicturePrivateApi.receiveSelectedImage", image_url);
       } else {
         // User has an old default image, so present it in the same manner as a
         // previous image from file.
         SendOldImage(user_manager::GetDefaultImageUrl(previous_image_index_));
       }
     }
   }
 }
 
-void ChangePictureOptionsHandler::SendProfileImage(const gfx::ImageSkia& image,
-                                                   bool should_select) {
+void ChangePictureHandler::SendProfileImage(const gfx::ImageSkia& image,
+                                            bool should_select) {
   base::StringValue data_url(webui::GetBitmapDataUrl(*image.bitmap()));
   base::FundamentalValue select(should_select);
-  web_ui()->CallJavascriptFunction("ChangePictureOptions.setProfileImage",
-                                   data_url, select);
+  web_ui()->CallJavascriptFunction(
+      "settings.ChangePicturePrivateApi.receiveProfileImage", data_url, select);
 }
 
-void ChangePictureOptionsHandler::UpdateProfileImage() {
+void ChangePictureHandler::UpdateProfileImage() {
   UserImageManager* user_image_manager =
       ChromeUserManager::Get()->GetUserImageManager(GetUser()->GetAccountId());
   // If we have a downloaded profile image and haven't sent it in
   // |SendSelectedImage|, send it now (without selecting).
   if (previous_image_index_ != user_manager::User::USER_IMAGE_PROFILE &&
       !user_image_manager->DownloadedProfileImage().isNull())
     SendProfileImage(user_image_manager->DownloadedProfileImage(), false);
 
   user_image_manager->DownloadProfileImage(kProfileDownloadReason);
 }
 
-void ChangePictureOptionsHandler::SendOldImage(const std::string& image_url) {
+void ChangePictureHandler::SendOldImage(const std::string& image_url) {
   previous_image_url_ = image_url;
   base::StringValue url(image_url);
-  web_ui()->CallJavascriptFunction("ChangePictureOptions.setOldImage", url);
+  web_ui()->CallJavascriptFunction(
+      "settings.ChangePicturePrivateApi.receiveOldImage", url);
 }
 
-void ChangePictureOptionsHandler::HandleSelectImage(
+void ChangePictureHandler::HandleSelectImage(
     const base::ListValue* args) {
   std::string image_url;
   std::string image_type;
   if (!args ||
       args->GetSize() != 2 ||
       !args->GetString(0, &image_url) ||
       !args->GetString(1, &image_type)) {
     NOTREACHED();
     return;
   }
@@ skipping 50 matching lines @@
     }
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 
   // Ignore the result of the previous decoding if it's no longer needed.
   if (!waiting_for_camera_photo)
     ImageDecoder::Cancel(this);
 }
 
-void ChangePictureOptionsHandler::FileSelected(const base::FilePath& path,
-                                               int index,
-                                               void* params) {
+void ChangePictureHandler::FileSelected(const base::FilePath& path,
+                                        int index,
+                                        void* params) {
   ChromeUserManager::Get()
       ->GetUserImageManager(GetUser()->GetAccountId())
       ->SaveUserImageFromFile(path);
   UMA_HISTOGRAM_ENUMERATION("UserImage.ChangeChoice",
                             user_manager::kHistogramImageFromFile,
                             user_manager::kHistogramImagesCount);
   VLOG(1) << "Selected image from file";
 }
 
-void ChangePictureOptionsHandler::SetImageFromCamera(
+void ChangePictureHandler::SetImageFromCamera(
     const gfx::ImageSkia& photo) {
   ChromeUserManager::Get()
       ->GetUserImageManager(GetUser()->GetAccountId())
       ->SaveUserImage(user_manager::UserImage::CreateAndEncode(photo));
   UMA_HISTOGRAM_ENUMERATION("UserImage.ChangeChoice",
                             user_manager::kHistogramImageFromCamera,
                             user_manager::kHistogramImagesCount);
   VLOG(1) << "Selected camera photo";
 }
 
-void ChangePictureOptionsHandler::SetCameraPresent(bool present) {
+void ChangePictureHandler::SetCameraPresent(bool present) {
   base::FundamentalValue present_value(present);
 
-  web_ui()->CallJavascriptFunction("ChangePictureOptions.setCameraPresent",
-                                   present_value);
+  web_ui()->CallJavascriptFunction(
+      "settings.ChangePicturePrivateApi.receiveCameraPresence", present_value);
 }
 
-void ChangePictureOptionsHandler::OnCameraPresenceCheckDone(
+void ChangePictureHandler::OnCameraPresenceCheckDone(
     bool is_camera_present) {
   SetCameraPresent(is_camera_present);
 }
 
-void ChangePictureOptionsHandler::Observe(
+void ChangePictureHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED) {
     // User profile image has been updated.
     SendProfileImage(*content::Details<const gfx::ImageSkia>(details).ptr(),
                      false);
   } else if (type == chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED) {
     // Not initialized yet.
     if (previous_image_index_ == user_manager::User::USER_IMAGE_INVALID)
       return;
     SendSelectedImage();
   }
 }
 
-gfx::NativeWindow ChangePictureOptionsHandler::GetBrowserWindow() const {
+gfx::NativeWindow ChangePictureHandler::GetBrowserWindow() const {
   Browser* browser =
       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents());
   return browser->window()->GetNativeWindow();
 }
 
-void ChangePictureOptionsHandler::OnImageDecoded(
+void ChangePictureHandler::OnImageDecoded(
     const SkBitmap& decoded_image) {
   user_photo_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
   SetImageFromCamera(user_photo_);
 }
 
-void ChangePictureOptionsHandler::OnDecodeImageFailed() {
+void ChangePictureHandler::OnDecodeImageFailed() {
   NOTREACHED() << "Failed to decode PNG image from WebUI";
 }
 
-const user_manager::User* ChangePictureOptionsHandler::GetUser() const {
+const user_manager::User* ChangePictureHandler::GetUser() const {
   Profile* profile = Profile::FromWebUI(web_ui());
   const user_manager::User* user =
       ProfileHelper::Get()->GetUserByProfile(profile);
   if (!user)
     return user_manager::UserManager::Get()->GetActiveUser();
   return user;
 }
 
-}  // namespace options
+}  // namespace settings
 }  // namespace chromeos