Simplify adding callbacks.

chrome/browser/ui/webui/chromeos/login/user_image_screen_handler.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 "chrome/browser/ui/webui/chromeos/login/user_image_screen_handler.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
@@ skipping 126 matching lines @@
 }
 
 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);
   }
 }
 
-void UserImageScreenHandler::HandleGetImages(const base::ListValue* args) {
-  DCHECK(args && !args->GetSize());
-
+void UserImageScreenHandler::HandleGetImages() {
   base::ListValue image_urls;
   for (int i = kFirstDefaultImageIndex; i < kDefaultImagesCount; ++i) {
     scoped_ptr<base::DictionaryValue> image_data(new base::DictionaryValue);
     image_data->SetString("url", GetDefaultImageUrl(i));
     image_data->SetString(
         "author", l10n_util::GetStringUTF16(kDefaultImageAuthorIDs[i]));
     image_data->SetString(
         "website", l10n_util::GetStringUTF16(kDefaultImageWebsiteIDs[i]));
     image_data->SetString("title", GetDefaultImageDescription(i));
     image_urls.Append(image_data.release());
   }
   CallJS("oobe.UserImageScreen.setDefaultImages", image_urls);
 
   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_)
     OnProfileImageAbsent();
 }
 
-void UserImageScreenHandler::HandlePhotoTaken(const base::ListValue* args) {
+void UserImageScreenHandler::HandlePhotoTaken(const std::string& image_url) {
   DCHECK(BrowserThread::CurrentlyOn(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;
 
   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 UserImageScreenHandler::HandleCheckCameraPresence(
-    const base::ListValue* args) {
-  DCHECK(args->empty());
+void UserImageScreenHandler::HandleCheckCameraPresence() {
   CheckCameraPresence();
 }
 
-void UserImageScreenHandler::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;
-  }
+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;
   }
 }
 
-void UserImageScreenHandler::HandleImageAccepted(const base::ListValue* args) {
-  DCHECK(args && args->empty());
+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_);
   }
 }
 
-void UserImageScreenHandler::HandleScreenShown(const base::ListValue* args) {
-  DCHECK(args && args->empty());
+void UserImageScreenHandler::HandleScreenShown() {
   DCHECK(!screen_show_time_.is_null());
 
   base::TimeDelta delta = base::Time::Now() - screen_show_time_;
   VLOG(1) << "Screen load time: " << delta.InSecondsF();
   UMA_HISTOGRAM_TIMES("UserImage.ScreenIsShownTime", delta);
 }
 
 void UserImageScreenHandler::OnCameraPresenceCheckDone() {
   base::FundamentalValue present_value(
       CameraDetector::camera_presence() == CameraDetector::kCameraPresent);
@@ skipping 11 matching lines @@
 void UserImageScreenHandler::OnDecodeImageFailed(const ImageDecoder* decoder) {
   NOTREACHED() << "Failed to decode PNG image from WebUI";
 }
 
 void UserImageScreenHandler::SetProfilePictureEnabled(bool enabled) {
   base::FundamentalValue present_value(enabled);
   CallJS("oobe.UserImageScreen.setProfilePictureEnabled", present_value);
 }
 
 }  // namespace chromeos