GAIA Profile info prototype

chrome/browser/profiles/profile_impl.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_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 121 matching lines @@
 #include "chrome/browser/password_manager/password_store_x.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/locale_change_guard.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/browser/chromeos/proxy_config_service_impl.h"
 #endif
 
+#include "chrome/browser/gaia_userinfo/profile_image_downloader.h"
+
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
+const char kHasMigratedToGAIAInfo[] = "test_profile_has_migrated_to_gaia_info";
+
+
+class GAIAInfoUpdater : public ProfileImageDownloader::Delegate {
+ public:
+  explicit GAIAInfoUpdater(Profile* profile);
+  bool IsFinishedUpdating();
+
+  // ProfileImageDownloader::Delegate:
+  virtual int GetDesiredImageSize() OVERRIDE;
+  virtual std::string GetProfileUserName() OVERRIDE;
+  virtual Profile* GetProfile() OVERRIDE;
+  virtual void OnDownloadSuccess(const SkBitmap& image,
+                                 const string16& full_name) OVERRIDE;
+  virtual void OnDownloadFailure() OVERRIDE;
+  virtual void OnDownloadDefaultImage() OVERRIDE;
+
+ private:
+  Profile* profile_;
+  bool is_finished_updating_;
+  scoped_ptr<ProfileImageDownloader> profile_image_downloader_;
+};
+
+GAIAInfoUpdater::GAIAInfoUpdater(Profile* profile)
+    : profile_(profile),
+      is_finished_updating_(false) {
+  profile_image_downloader_.reset(new ProfileImageDownloader(this));
+  profile_image_downloader_->Start();
+}
+
+bool GAIAInfoUpdater::IsFinishedUpdating() {
+  return is_finished_updating_;
+}
+
+int GAIAInfoUpdater::GetDesiredImageSize() {
+  return 256;
+}
+
+std::string GAIAInfoUpdater::GetProfileUserName() {
+  return profile_->GetPrefs()->GetString(prefs::kGoogleServicesUsername);
+}
+
+Profile* GAIAInfoUpdater::GetProfile() {
+  return profile_;
+}
+
+void GAIAInfoUpdater::OnDownloadSuccess(const SkBitmap& image,
+                                        const string16& full_name) {
+  fprintf(stderr, "%s\n", __func__);
+  ProfileInfoCache& cache =
+      g_browser_process->profile_manager()->GetProfileInfoCache();
+  size_t profile_index = cache.GetIndexOfProfileWithPath(profile_->GetPath());
+  if (profile_index != std::string::npos) {
+    cache.SetGAIANameOfProfileAtIndex(profile_index, full_name);
+    cache.SetGAIAPictureOfProfileAtIndex(profile_index, image);
+
+    if (!profile_->GetPrefs()->GetBoolean(kHasMigratedToGAIAInfo)) {
+      fprintf(stderr, "%s, migrating to gaia image and name\n", __func__);
+      profile_->GetPrefs()->SetBoolean(kHasMigratedToGAIAInfo, true);
+      if (!image.isNull()) {
+        cache.SetIsUsingCustomAvatarIconForProfileAtIndex(profile_index, true);
+      }
+      if (!full_name.empty()) {
+        cache.SetIsUsingGAIANameForProfileAtIndex(profile_index, true);
+      }
+    }
+  }
+  is_finished_updating_ = true;
+}
+
+void GAIAInfoUpdater::OnDownloadFailure() {
+  fprintf(stderr, "%s\n", __func__);
+  is_finished_updating_ = true;
+}
+
+void GAIAInfoUpdater::OnDownloadDefaultImage() {
+  fprintf(stderr, "%s\n", __func__);
+  is_finished_updating_ = true;
+}
+
 namespace {
 
 // Delay, in milliseconds, before we explicitly create the SessionService.
 static const int kCreateSessionServiceDelayMS = 500;
 
 #if defined(OS_MACOSX)
 // Capacity for mock keychain used for testing.
 static const int kMockKeychainSize = 1000;
 #endif
 
@@ skipping 87 matching lines @@
                              false,
                              PrefService::SYNCABLE_PREF);
 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS) && defined(OS_POSIX)
   prefs->RegisterIntegerPref(prefs::kLocalProfileId,
                              kInvalidLocalProfileId,
                              PrefService::UNSYNCABLE_PREF);
   // Notice that the preprocessor conditions above are exactly those that will
   // result in using PasswordStoreX in CreatePasswordStore() below.
   PasswordStoreX::RegisterUserPrefs(prefs);
 #endif
+
+  prefs->RegisterBooleanPref(kHasMigratedToGAIAInfo,
+                             false,
+                             PrefService::UNSYNCABLE_PREF);
 }
 
 ProfileImpl::ProfileImpl(const FilePath& path,
                          Profile::Delegate* delegate)
     : path_(path),
       ALLOW_THIS_IN_INITIALIZER_LIST(visited_link_event_listener_(
           new VisitedLinkEventListener(this))),
       extension_devtools_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_data_(this)),
       host_content_settings_map_(NULL),
@@ skipping 1088 matching lines @@
               host, Value::CreateDoubleValue(level));
         }
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+void ProfileImpl::UpdateGAIAProfileInfo() {
+  if (gaia_info_updated_.get() && !gaia_info_updated_->IsFinishedUpdating()) {
+    fprintf(stderr, "%s, skipping updating because old one is pending\n",
+        __func__);
+    return;
+  }
+
+  fprintf(stderr, "%s, starting new GAIA profile info update\n", __func__);
+  gaia_info_updated_.reset(new GAIAInfoUpdater(this));
+}
+
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 void ProfileImpl::EnsureSessionServiceCreated() {
   SessionServiceFactory::GetForProfile(this);
 }
 
 TokenService* ProfileImpl::GetTokenService() {
   if (!token_service_.get()) {
@@ skipping 217 matching lines @@
   if (!home_page.is_valid())
     return GURL(chrome::kChromeUINewTabURL);
   return home_page;
 }
 
 SpellCheckProfile* ProfileImpl::GetSpellCheckProfile() {
   if (!spellcheck_profile_.get())
     spellcheck_profile_.reset(new SpellCheckProfile(path_));
   return spellcheck_profile_.get();
 }
+