Cache GAIA profile picture URL

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/profiles/profile_downloader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 166 matching lines @@
 
   // 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));
 }
 
 ProfileDownloader::ProfileDownloader(ProfileDownloaderDelegate* delegate)
-    : delegate_(delegate) {
+    : delegate_(delegate),
+      picture_status_(PICTURE_FAILED) {
   DCHECK(delegate_);
 }
 
 void ProfileDownloader::Start() {
   VLOG(1) << "Starting profile downloader...";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TokenService* service = delegate_->GetBrowserProfile()->GetTokenService();
   if (!service) {
     // This can happen in some test paths.
@@ skipping 21 matching lines @@
 }
 
 string16 ProfileDownloader::GetProfileFullName() const {
   return profile_full_name_;
 }
 
 SkBitmap ProfileDownloader::GetProfilePicture() const {
   return profile_picture_;
 }
 
+ProfileDownloader::PictureStatus ProfileDownloader::GetProfilePictureStatus()
+    const {
+  return picture_status_;
+}
+
+std::string ProfileDownloader::GetProfilePictureURL() const {
+  return picture_url_;
+}
+
 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(
       delegate_->GetBrowserProfile()->GetRequestContext());
   if (!auth_token_.empty()) {
     user_entry_fetcher_->SetExtraRequestHeaders(
         base::StringPrintf(GetAuthorizationHeader(), auth_token_.c_str()));
   }
@@ skipping 34 matching lines @@
     return;
   }
 
   if (source == user_entry_fetcher_.get()) {
     std::string image_url;
     if (!GetProfileNickNameAndImageURL(data, &profile_full_name_, &image_url)) {
       delegate_->OnDownloadComplete(this, false);
       return;
     }
     if (IsDefaultProfileImageURL(image_url)) {
+      VLOG(1) << "User has default profile picture";
+      picture_status_ = PICTURE_DEFAULT;
+      delegate_->OnDownloadComplete(this, true);
+      return;
+    }
+    if (!image_url.empty() && image_url == delegate_->GetCachedPictureURL()) {
+      VLOG(1) << "Picture URL matches cached picture URL";
+      picture_status_ = PICTURE_CACHED;
       delegate_->OnDownloadComplete(this, true);
       return;
     }
     VLOG(1) << "Fetching profile image from " << image_url;
+    picture_url_ = image_url;
     profile_image_fetcher_.reset(content::URLFetcher::Create(
         GURL(image_url), content::URLFetcher::GET, this));
     profile_image_fetcher_->SetRequestContext(
         delegate_->GetBrowserProfile()->GetRequestContext());
     if (!auth_token_.empty()) {
       profile_image_fetcher_->SetExtraRequestHeaders(
           base::StringPrintf(GetAuthorizationHeader(), 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 ProfileDownloader::OnImageDecoded(const ImageDecoder* decoder,
                                        const SkBitmap& decoded_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int image_size = delegate_->GetDesiredImageSideLength();
   profile_picture_ = skia::ImageOperations::Resize(
       decoded_image,
       skia::ImageOperations::RESIZE_BEST,
       image_size,
       image_size);
+  picture_status_ = PICTURE_SUCCESS;
   delegate_->OnDownloadComplete(this, true);
 }
 
 void ProfileDownloader::OnDecodeImageFailed(const ImageDecoder* decoder) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   delegate_->OnDownloadComplete(this, false);
 }
 
 void ProfileDownloader::Observe(
     int type,
@@ skipping 31 matching lines @@
 void ProfileDownloader::OnGetTokenSuccess(const std::string& access_token) {
   auth_token_ = access_token;
   StartFetchingImage();
 }
 
 // Callback for OAuth2AccessTokenFetcher on failure.
 void ProfileDownloader::OnGetTokenFailure(const GoogleServiceAuthError& error) {
   LOG(WARNING) << "ProfileDownloader: token request using refresh token failed";
   delegate_->OnDownloadComplete(this, false);
 }