Make ProfileImageDownloader available to non-chromeos code

chrome/browser/profiles/profile_downloader.cc

 // Copyright (c) 2011 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/profile_image_downloader.h"
+#include "chrome/browser/profiles/profile_downloader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "chrome/browser/chromeos/login/helper.h"
-#include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/net/gaia/token_service.h"
-#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_downloader_delegate.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "skia/ext/image_operations.h"
 
 using content::BrowserThread;
 
-namespace chromeos {
-
 namespace {
 
 // Template for optional authorization header.
 const char kAuthorizationHeader[] = "Authorization: GoogleLogin auth=%s";
 
 // URL requesting Picasa API for user info.
 const char kUserEntryURL[] =
     "http://picasaweb.google.com/data/entry/api/user/default?alt=json";
 // Path in JSON dictionary to user's photo thumbnail URL.
 const char kPhotoThumbnailURLPath[] = "entry.gphoto$thumbnail.$t";
+
+const char kNickNamePath[] = "entry.gphoto$nickname.$t";
+
 // Path format for specifying thumbnail's size.
 const char kThumbnailSizeFormat[] = "s%d-c";
 // Default Picasa thumbnail size.
 const int kDefaultThumbnailSize = 64;
 
 // Separator of URL path components.
 const char kURLPathSeparator = '/';
 
 // Photo ID of the Picasa Web Albums profile picture (base64 of 0).
 const char kPicasaPhotoId[] = "AAAAAAAAAAA";
@@ skipping 11 matching lines @@
 const size_t kProfileImageURLPathComponentsCount = 7;
 
 // Index of path component with photo ID.
 const int kPhotoIdPathComponentIndex = 2;
 
 // Index of path component with photo version.
 const int kPhotoVersionPathComponentIndex = 3;
 
 }  // namespace
 
-std::string ProfileImageDownloader::GetProfileImageURL(
-    const std::string& data) const {
+bool ProfileDownloader::GetProfileNickNameAndImageURL(const std::string& data,
+                                                      string16* nick_name,
+                                                      std::string* url) const {
+  DCHECK(nick_name);
+  DCHECK(url);
+  *nick_name = string16();
+  *url = std::string();
+
   int error_code = -1;
   std::string error_message;
   scoped_ptr<base::Value> root_value(base::JSONReader::ReadAndReturnError(
       data, false, &error_code, &error_message));
   if (!root_value.get()) {
     LOG(ERROR) << "Error while parsing Picasa user entry response: "
                << error_message;
-    return std::string();
+    return false;
   }
   if (!root_value->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "JSON root is not a dictionary: "
                << root_value->GetType();
-    return std::string();
+    return false;
   }
   base::DictionaryValue* root_dictionary =
       static_cast<base::DictionaryValue*>(root_value.get());
 
+  if (!root_dictionary->GetString(kNickNamePath, nick_name)) {
+    LOG(ERROR) << "Can't find nick name path in JSON data: "
+               << data;
+    return false;
+  }
+
   std::string thumbnail_url_string;
   if (!root_dictionary->GetString(
           kPhotoThumbnailURLPath, &thumbnail_url_string)) {
     LOG(ERROR) << "Can't find thumbnail path in JSON data: "
                << data;
-    return std::string();
+    return false;
   }
 
   // Try to change the size of thumbnail we are going to get.
   // Typical URL looks like this:
   // http://lh0.ggpht.com/-abcd1aBCDEf/AAAA/AAA_A/abc12/s64-c/1234567890.jpg
   std::string default_thumbnail_size_path_component(
       base::StringPrintf(kThumbnailSizeFormat, kDefaultThumbnailSize));
+  int image_size = delegate_->GetDesiredImageSideLength();
   std::string new_thumbnail_size_path_component(
-      base::StringPrintf(kThumbnailSizeFormat, login::kUserImageSize));
+      base::StringPrintf(kThumbnailSizeFormat, image_size));
   size_t thumbnail_size_pos =
       thumbnail_url_string.find(default_thumbnail_size_path_component);
   if (thumbnail_size_pos != std::string::npos) {
     size_t thumbnail_size_end =
         thumbnail_size_pos + default_thumbnail_size_path_component.size();
    thumbnail_url_string =
         thumbnail_url_string.substr(0, thumbnail_size_pos) +
         new_thumbnail_size_path_component +
         thumbnail_url_string.substr(
             thumbnail_size_end,
             thumbnail_url_string.size() - thumbnail_size_end);
   } else {
     LOG(WARNING) << "Hasn't found thumbnail size part in image URL: "
                  << thumbnail_url_string;
     // Use the thumbnail URL we have.
   }
 
   GURL thumbnail_url(thumbnail_url_string);
   if (!thumbnail_url.is_valid()) {
     LOG(ERROR) << "Thumbnail URL is not valid: " << thumbnail_url_string;
-    return std::string();
+    return false;
   }
-  return thumbnail_url.spec();
+  *url = thumbnail_url.spec();
+  return true;
 }
 
-bool ProfileImageDownloader::IsDefaultProfileImageURL(
-    const std::string& url) const {
-
+bool ProfileDownloader::IsDefaultProfileImageURL(const std::string& url) const {
   GURL image_url_object(url);
   DCHECK(image_url_object.is_valid());
   VLOG(1) << "URL to check for default image: " << image_url_object.spec();
   std::vector<std::string> path_components;
   base::SplitString(image_url_object.path(),
                     kURLPathSeparator,
                     &path_components);
 
   if (path_components.size() != kProfileImageURLPathComponentsCount)
     return false;
 
   const std::string& photo_id = path_components[kPhotoIdPathComponentIndex];
   const std::string& photo_version =
       path_components[kPhotoVersionPathComponentIndex];
 
   // There are at least two pairs of (ID, version) for the default photo:
   // the default Google+ profile photo and the default Picasa profile photo.
   return ((photo_id == kPicasaPhotoId &&
            photo_version == kDefaultPicasaPhotoVersion) ||
           (photo_id == kGooglePlusPhotoId &&
            photo_version == kDefaultGooglePlusPhotoVersion));
 }
 
-ProfileImageDownloader::ProfileImageDownloader(Delegate* delegate)
+ProfileDownloader::ProfileDownloader(ProfileDownloaderDelegate* delegate)
     : delegate_(delegate) {
+  DCHECK(delegate_);
 }
 
-void ProfileImageDownloader::Start() {
-  VLOG(1) << "Starting profile image downloader...";
+void ProfileDownloader::Start() {
+  VLOG(1) << "Starting profile downloader...";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  TokenService* service =
-      ProfileManager::GetDefaultProfile()->GetTokenService();
+  TokenService* service = delegate_->GetBrowserProfile()->GetTokenService();
   if (!service) {
     // This can happen in some test paths.
     LOG(WARNING) << "User has no token service";
-    if (delegate_)
-      delegate_->OnDownloadFailure();
+    delegate_->OnDownloadComplete(this, false);
     return;
   }
   if (service->HasTokenForService(GaiaConstants::kPicasaService)) {
     auth_token_ =
         service->GetTokenForService(GaiaConstants::kPicasaService);
     StartFetchingImage();
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TOKEN_AVAILABLE,
                    content::Source<TokenService>(service));
     registrar_.Add(this,
                    chrome::NOTIFICATION_TOKEN_REQUEST_FAILED,
                    content::Source<TokenService>(service));
   }
 }
 
-void ProfileImageDownloader::StartFetchingImage() {
-  std::string email = UserManager::Get()->logged_in_user().email();
-  if (email.empty())
-    return;
+const string16& ProfileDownloader::GetProfileFullName() const {
+  return profile_full_name_;
+}
+
+const SkBitmap& ProfileDownloader::GetProfilePicture() const {
+  return profile_picture_;
+}
+
+void ProfileDownloader::StartFetchingImage() {
   VLOG(1) << "Fetching user entry with token: " << auth_token_;
   user_entry_fetcher_.reset(content::URLFetcher::Create(
       GURL(kUserEntryURL), content::URLFetcher::GET, this));
   user_entry_fetcher_->SetRequestContext(
-      ProfileManager::GetDefaultProfile()->GetRequestContext());
+      delegate_->GetBrowserProfile()->GetRequestContext());
   if (!auth_token_.empty()) {
     user_entry_fetcher_->SetExtraRequestHeaders(
         base::StringPrintf(kAuthorizationHeader, auth_token_.c_str()));
   }
   user_entry_fetcher_->Start();
 }
 
-ProfileImageDownloader::~ProfileImageDownloader() {}
+ProfileDownloader::~ProfileDownloader() {}
 
-void ProfileImageDownloader::OnURLFetchComplete(
-    const content::URLFetcher* source) {
+void ProfileDownloader::OnURLFetchComplete(const content::URLFetcher* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string data;
   source->GetResponseAsString(&data);
   if (source->GetResponseCode() != 200) {
     LOG(ERROR) << "Response code is " << source->GetResponseCode();
     LOG(ERROR) << "Url is " << source->GetURL().spec();
     LOG(ERROR) << "Data is " << data;
-    if (delegate_)
-      delegate_->OnDownloadFailure();
+    delegate_->OnDownloadComplete(this, false);
     return;
   }
 
   if (source == user_entry_fetcher_.get()) {
-    std::string image_url = GetProfileImageURL(data);
-    if (image_url.empty()) {
-      if (delegate_)
-        delegate_->OnDownloadFailure();
+    std::string image_url;
+    if (!GetProfileNickNameAndImageURL(data, &profile_full_name_, &image_url)) {
+      delegate_->OnDownloadComplete(this, false);
       return;
     }
     if (IsDefaultProfileImageURL(image_url)) {
-      if (delegate_)
-        delegate_->OnDownloadDefaultImage();
+      delegate_->OnDownloadComplete(this, true);
       return;
     }
     VLOG(1) << "Fetching profile image from " << image_url;
     profile_image_fetcher_.reset(content::URLFetcher::Create(
         GURL(image_url), content::URLFetcher::GET, this));
     profile_image_fetcher_->SetRequestContext(
-        ProfileManager::GetDefaultProfile()->GetRequestContext());
+        delegate_->GetBrowserProfile()->GetRequestContext());
     if (!auth_token_.empty()) {
       profile_image_fetcher_->SetExtraRequestHeaders(
           base::StringPrintf(kAuthorizationHeader, auth_token_.c_str()));
     }
     profile_image_fetcher_->Start();
   } else if (source == profile_image_fetcher_.get()) {
     VLOG(1) << "Decoding the image...";
     scoped_refptr<ImageDecoder> image_decoder = new ImageDecoder(
         this, data);
     image_decoder->Start();
   }
 }
 
-void ProfileImageDownloader::OnImageDecoded(const ImageDecoder* decoder,
-                                            const SkBitmap& decoded_image) {
+void ProfileDownloader::OnImageDecoded(const ImageDecoder* decoder,
+                                       const SkBitmap& decoded_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SkBitmap resized_image = skia::ImageOperations::Resize(
+  int image_size = delegate_->GetDesiredImageSideLength();
+  profile_picture_ = skia::ImageOperations::Resize(
       decoded_image,
       skia::ImageOperations::RESIZE_BEST,
-      login::kUserImageSize,
-      login::kUserImageSize);
-  if (delegate_)
-    delegate_->OnDownloadSuccess(resized_image);
+      image_size,
+      image_size);
+  delegate_->OnDownloadComplete(this, true);
 }
 
-void ProfileImageDownloader::OnDecodeImageFailed(const ImageDecoder* decoder) {
+void ProfileDownloader::OnDecodeImageFailed(const ImageDecoder* decoder) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (delegate_)
-    delegate_->OnDownloadFailure();
+  delegate_->OnDownloadComplete(this, false);
 }
 
-void ProfileImageDownloader::Observe(
+void ProfileDownloader::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TOKEN_AVAILABLE ||
          type == chrome::NOTIFICATION_TOKEN_REQUEST_FAILED);
 
   TokenService::TokenAvailableDetails* token_details =
       content::Details<TokenService::TokenAvailableDetails>(details).ptr();
   if (type == chrome::NOTIFICATION_TOKEN_AVAILABLE) {
     if (token_details->service() == GaiaConstants::kPicasaService) {
       registrar_.RemoveAll();
       auth_token_ = token_details->token();
       StartFetchingImage();
     }
   } else {
     if (token_details->service() == GaiaConstants::kPicasaService) {
-      LOG(WARNING) << "ProfileImageDownloader: token request failed";
-      if (delegate_)
-        delegate_->OnDownloadFailure();
+      LOG(WARNING) << "ProfileDownloader: token request failed";
+      delegate_->OnDownloadComplete(this, false);
     }
   }
 }
-
-}  // namespace chromeos