chrome/browser/chromeos/login/user_image_manager_impl.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/file_util.h"
  10 #include "base/files/file_path.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop/message_loop_proxy.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/path_service.h"
  15 #include "base/prefs/pref_registry_simple.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/prefs/scoped_user_pref_update.h"
  18 #include "base/rand_util.h"
  19 #include "base/sequenced_task_runner.h"
  20 #include "base/task_runner_util.h"
  21 #include "base/threading/sequenced_worker_pool.h"
  22 #include "base/time/time.h"
  23 #include "base/values.h"
  24 #include "chrome/browser/browser_process.h"
  25 #include "chrome/browser/chrome_notification_types.h"
  26 #include "chrome/browser/chromeos/login/default_user_images.h"
  27 #include "chrome/browser/chromeos/login/helper.h"
  28 #include "chrome/browser/chromeos/login/user_image.h"
  29 #include "chrome/browser/chromeos/login/user_image_sync_observer.h"
  30 #include "chrome/browser/chromeos/login/user_manager.h"
  31 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
  32 #include "chrome/browser/profiles/profile_downloader.h"
  33 #include "chrome/browser/profiles/profile_manager.h"
  34 #include "chrome/common/chrome_paths.h"
  35 #include "content/public/browser/browser_thread.h"
  36 #include "content/public/browser/notification_service.h"
  37 #include "policy/policy_constants.h"
  38 #include "ui/gfx/image/image_skia.h"
  39
  40 namespace chromeos {
  41
  42 namespace {
  43
  44 // A dictionary that maps user_ids to old user image data with images stored in
  45 // PNG format. Deprecated.
  46 // TODO(ivankr): remove this const char after migration is gone.
  47 const char kUserImages[] = "UserImages";
  48
  49 // A dictionary that maps user_ids to user image data with images stored in
  50 // JPEG format.
  51 const char kUserImageProperties[] = "user_image_info";
  52
  53 // Names of user image properties.
  54 const char kImagePathNodeName[] = "path";
  55 const char kImageIndexNodeName[] = "index";
  56 const char kImageURLNodeName[] = "url";
  57
  58 // Delay betweeen user login and attempt to update user's profile data.
  59 const int kProfileDataDownloadDelaySec = 10;
  60
  61 // Interval betweeen retries to update user's profile data.
  62 const int kProfileDataDownloadRetryIntervalSec = 300;
  63
  64 // Delay betweeen subsequent profile refresh attempts (24 hrs).
  65 const int kProfileRefreshIntervalSec = 24 * 3600;
  66
  67 const char kSafeImagePathExtension[] = ".jpg";
  68
  69 // Enum for reporting histograms about profile picture download.
  70 enum ProfileDownloadResult {
  71   kDownloadSuccessChanged,
  72   kDownloadSuccess,
  73   kDownloadFailure,
  74   kDownloadDefault,
  75   kDownloadCached,
  76
  77   // Must be the last, convenient count.
  78   kDownloadResultsCount
  79 };
  80
  81 // Time histogram prefix for a cached profile image download.
  82 const char kProfileDownloadCachedTime[] =
  83     "UserImage.ProfileDownloadTime.Cached";
  84 // Time histogram prefix for the default profile image download.
  85 const char kProfileDownloadDefaultTime[] =
  86     "UserImage.ProfileDownloadTime.Default";
  87 // Time histogram prefix for a failed profile image download.
  88 const char kProfileDownloadFailureTime[] =
  89     "UserImage.ProfileDownloadTime.Failure";
  90 // Time histogram prefix for a successful profile image download.
  91 const char kProfileDownloadSuccessTime[] =
  92     "UserImage.ProfileDownloadTime.Success";
  93 // Time histogram suffix for a profile image download after login.
  94 const char kProfileDownloadReasonLoggedIn[] = "LoggedIn";
  95 // Time histogram suffix for a profile image download when the user chooses the
  96 // profile image but it has not been downloaded yet.
  97 const char kProfileDownloadReasonProfileImageChosen[] = "ProfileImageChosen";
  98 // Time histogram suffix for a scheduled profile image download.
  99 const char kProfileDownloadReasonScheduled[] = "Scheduled";
 100 // Time histogram suffix for a profile image download retry.
 101 const char kProfileDownloadReasonRetry[] = "Retry";
 102
 103 static bool g_ignore_profile_data_download_delay_ = false;
 104
 105 // Add a histogram showing the time it takes to download profile image.
 106 // Separate histograms are reported for each download |reason| and |result|.
 107 void AddProfileImageTimeHistogram(ProfileDownloadResult result,
 108                                   const std::string& download_reason,
 109                                   const base::TimeDelta& time_delta) {
 110   std::string histogram_name;
 111   switch (result) {
 112     case kDownloadFailure:
 113       histogram_name = kProfileDownloadFailureTime;
 114       break;
 115     case kDownloadDefault:
 116       histogram_name = kProfileDownloadDefaultTime;
 117       break;
 118     case kDownloadSuccess:
 119       histogram_name = kProfileDownloadSuccessTime;
 120       break;
 121     case kDownloadCached:
 122       histogram_name = kProfileDownloadCachedTime;
 123       break;
 124     default:
 125       NOTREACHED();
 126   }
 127   if (!download_reason.empty()) {
 128     histogram_name += ".";
 129     histogram_name += download_reason;
 130   }
 131
 132   static const base::TimeDelta min_time = base::TimeDelta::FromMilliseconds(1);
 133   static const base::TimeDelta max_time = base::TimeDelta::FromSeconds(50);
 134   const size_t bucket_count(50);
 135
 136   base::HistogramBase* counter = base::Histogram::FactoryTimeGet(
 137       histogram_name, min_time, max_time, bucket_count,
 138       base::HistogramBase::kUmaTargetedHistogramFlag);
 139   counter->AddTime(time_delta);
 140
 141   DVLOG(1) << "Profile image download time: " << time_delta.InSecondsF();
 142 }
 143
 144 // Converts |image_index| to UMA histogram value.
 145 int ImageIndexToHistogramIndex(int image_index) {
 146   switch (image_index) {
 147     case User::kExternalImageIndex:
 148       // TODO(ivankr): Distinguish this from selected from file.
 149       return kHistogramImageFromCamera;
 150     case User::kProfileImageIndex:
 151       return kHistogramImageFromProfile;
 152     default:
 153       return image_index;
 154   }
 155 }
 156
 157 bool SaveImage(const UserImage& user_image, const base::FilePath& image_path) {
 158   UserImage safe_image;
 159   const UserImage::RawImage* encoded_image = NULL;
 160   if (!user_image.is_safe_format()) {
 161     safe_image = UserImage::CreateAndEncode(user_image.image());
 162     encoded_image = &safe_image.raw_image();
 163     UMA_HISTOGRAM_MEMORY_KB("UserImage.RecodedJpegSize", encoded_image->size());
 164   } else if (user_image.has_raw_image()) {
 165     encoded_image = &user_image.raw_image();
 166   } else {
 167     NOTREACHED() << "Raw image missing.";
 168     return false;
 169   }
 170
 171   if (!encoded_image->size() ||
 172       base::WriteFile(image_path,
 173                       reinterpret_cast<const char*>(&(*encoded_image)[0]),
 174                       encoded_image->size()) == -1) {
 175     LOG(ERROR) << "Failed to save image to file.";
 176     return false;
 177   }
 178
 179   return true;
 180 }
 181
 182 }  // namespace
 183
 184 // static
 185 void UserImageManager::RegisterPrefs(PrefRegistrySimple* registry) {
 186   registry->RegisterDictionaryPref(kUserImages);
 187   registry->RegisterDictionaryPref(kUserImageProperties);
 188 }
 189
 190 // Every image load or update is encapsulated by a Job. The Job is allowed to
 191 // perform tasks on background threads or in helper processes but:
 192 // * Changes to User objects and local state as well as any calls to the
 193 //   |parent_| must be performed on the thread that the Job is created on only.
 194 // * File writes and deletions must be performed via the |parent_|'s
 195 //   |background_task_runner_| only.
 196 //
 197 // Only one of the Load*() and Set*() methods may be called per Job.
 198 class UserImageManagerImpl::Job {
 199  public:
 200   // The |Job| will update the user object corresponding to |parent|.
 201   explicit Job(UserImageManagerImpl* parent);
 202   ~Job();
 203
 204   // Loads the image at |image_path| or one of the default images,
 205   // depending on |image_index|, and updates the user object with the
 206   // new image.
 207   void LoadImage(base::FilePath image_path,
 208                  const int image_index,
 209                  const GURL& image_url);
 210
 211   // Sets the user image in local state to the default image indicated
 212   // by |default_image_index|. Also updates the user object with the
 213   // new image.
 214   void SetToDefaultImage(int default_image_index);
 215
 216   // Saves the |user_image| to disk and sets the user image in local
 217   // state to that image. Also updates the user with the new image.
 218   void SetToImage(int image_index, const UserImage& user_image);
 219
 220   // Decodes the JPEG image |data|, crops and resizes the image, saves
 221   // it to disk and sets the user image in local state to that image.
 222   // Also updates the user object with the new image.
 223   void SetToImageData(scoped_ptr<std::string> data);
 224
 225   // Loads the image at |path|, transcodes it to JPEG format, saves
 226   // the image to disk and sets the user image in local state to that
 227   // image.  If |resize| is true, the image is cropped and resized
 228   // before transcoding.  Also updates the user object with the new
 229   // image.
 230   void SetToPath(const base::FilePath& path,
 231                  int image_index,
 232                  const GURL& image_url,
 233                  bool resize);
 234
 235  private:
 236   // Called back after an image has been loaded from disk.
 237   void OnLoadImageDone(bool save, const UserImage& user_image);
 238
 239   // Updates the user object with |user_image_|.
 240   void UpdateUser();
 241
 242   // Saves |user_image_| to disk in JPEG format. Local state will be updated
 243   // when a callback indicates that the image has been saved.
 244   void SaveImageAndUpdateLocalState();
 245
 246   // Called back after the |user_image_| has been saved to
 247   // disk. Updates the user image information in local state. The
 248   // information is only updated if |success| is true (indicating that
 249   // the image was saved successfully) or the user image is the
 250   // profile image (indicating that even if the image could not be
 251   // saved because it is not available right now, it will be
 252   // downloaded eventually).
 253   void OnSaveImageDone(bool success);
 254
 255   // Updates the user image in local state, setting it to one of the
 256   // default images or the saved |user_image_|, depending on
 257   // |image_index_|.
 258   void UpdateLocalState();
 259
 260   // Notifies the |parent_| that the Job is done.
 261   void NotifyJobDone();
 262
 263   const std::string& user_id() const { return parent_->user_id(); }
 264
 265   UserImageManagerImpl* parent_;
 266
 267   // Whether one of the Load*() or Set*() methods has been run already.
 268   bool run_;
 269
 270   int image_index_;
 271   GURL image_url_;
 272   base::FilePath image_path_;
 273
 274   UserImage user_image_;
 275
 276   base::WeakPtrFactory<Job> weak_factory_;
 277
 278   DISALLOW_COPY_AND_ASSIGN(Job);
 279 };
 280
 281 UserImageManagerImpl::Job::Job(UserImageManagerImpl* parent)
 282     : parent_(parent),
 283       run_(false),
 284       weak_factory_(this) {
 285 }
 286
 287 UserImageManagerImpl::Job::~Job() {
 288 }
 289
 290 void UserImageManagerImpl::Job::LoadImage(base::FilePath image_path,
 291                                           const int image_index,
 292                                           const GURL& image_url) {
 293   DCHECK(!run_);
 294   run_ = true;
 295
 296   image_index_ = image_index;
 297   image_url_ = image_url;
 298   image_path_ = image_path;
 299
 300   if (image_index_ >= 0 && image_index_ < kDefaultImagesCount) {
 301     // Load one of the default images. This happens synchronously.
 302     user_image_ = UserImage(GetDefaultImage(image_index_));
 303     UpdateUser();
 304     NotifyJobDone();
 305   } else if (image_index_ == User::kExternalImageIndex ||
 306              image_index_ == User::kProfileImageIndex) {
 307     // Load the user image from a file referenced by |image_path|. This happens
 308     // asynchronously. The JPEG image loader can be used here because
 309     // LoadImage() is called only for users whose user image has previously
 310     // been set by one of the Set*() methods, which transcode to JPEG format.
 311     DCHECK(!image_path_.empty());
 312     parent_->image_loader_->Start(image_path_.value(),
 313                                   0,
 314                                   base::Bind(&Job::OnLoadImageDone,
 315                                              weak_factory_.GetWeakPtr(),
 316                                              false));
 317   } else {
 318     NOTREACHED();
 319     NotifyJobDone();
 320   }
 321 }
 322
 323 void UserImageManagerImpl::Job::SetToDefaultImage(int default_image_index) {
 324   DCHECK(!run_);
 325   run_ = true;
 326
 327   DCHECK_LE(0, default_image_index);
 328   DCHECK_GT(kDefaultImagesCount, default_image_index);
 329
 330   image_index_ = default_image_index;
 331   user_image_ = UserImage(GetDefaultImage(image_index_));
 332
 333   UpdateUser();
 334   UpdateLocalState();
 335   NotifyJobDone();
 336 }
 337
 338 void UserImageManagerImpl::Job::SetToImage(int image_index,
 339                                            const UserImage& user_image) {
 340   DCHECK(!run_);
 341   run_ = true;
 342
 343   DCHECK(image_index == User::kExternalImageIndex ||
 344          image_index == User::kProfileImageIndex);
 345
 346   image_index_ = image_index;
 347   user_image_ = user_image;
 348
 349   UpdateUser();
 350   SaveImageAndUpdateLocalState();
 351 }
 352
 353 void UserImageManagerImpl::Job::SetToImageData(scoped_ptr<std::string> data) {
 354   DCHECK(!run_);
 355   run_ = true;
 356
 357   image_index_ = User::kExternalImageIndex;
 358
 359   // This method uses the image_loader_, not the unsafe_image_loader_:
 360   // * This is necessary because the method is used to update the user image
 361   //   whenever the policy for a user is set. In the case of device-local
 362   //   accounts, policy may change at any time, even if the user is not
 363   //   currently logged in (and thus, the unsafe_image_loader_ may not be used).
 364   // * This is possible because only JPEG |data| is accepted. No support for
 365   //   other image file formats is needed.
 366   // * This is safe because the image_loader_ employs a hardened JPEG decoder
 367   //   that protects against malicious invalid image data being used to attack
 368   //   the login screen or another user session currently in progress.
 369   parent_->image_loader_->Start(data.Pass(),
 370                                 login::kMaxUserImageSize,
 371                                 base::Bind(&Job::OnLoadImageDone,
 372                                            weak_factory_.GetWeakPtr(),
 373                                            true));
 374 }
 375
 376 void UserImageManagerImpl::Job::SetToPath(const base::FilePath& path,
 377                                           int image_index,
 378                                           const GURL& image_url,
 379                                           bool resize) {
 380   DCHECK(!run_);
 381   run_ = true;
 382
 383   image_index_ = image_index;
 384   image_url_ = image_url;
 385
 386   DCHECK(!path.empty());
 387   parent_->unsafe_image_loader_->Start(path.value(),
 388                                        resize ? login::kMaxUserImageSize : 0,
 389                                        base::Bind(&Job::OnLoadImageDone,
 390                                                   weak_factory_.GetWeakPtr(),
 391                                                   true));
 392 }
 393
 394 void UserImageManagerImpl::Job::OnLoadImageDone(bool save,
 395                                                 const UserImage& user_image) {
 396   user_image_ = user_image;
 397   UpdateUser();
 398   if (save)
 399     SaveImageAndUpdateLocalState();
 400   else
 401     NotifyJobDone();
 402 }
 403
 404 void UserImageManagerImpl::Job::UpdateUser() {
 405   User* user = parent_->user_manager_->FindUserAndModify(user_id());
 406   if (!user)
 407     return;
 408
 409   if (!user_image_.image().isNull())
 410     user->SetImage(user_image_, image_index_);
 411   else
 412     user->SetStubImage(image_index_, false);
 413   user->SetImageURL(image_url_);
 414
 415   parent_->OnJobChangedUserImage();
 416 }
 417
 418 void UserImageManagerImpl::Job::SaveImageAndUpdateLocalState() {
 419   base::FilePath user_data_dir;
 420   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 421   image_path_ = user_data_dir.Append(user_id() + kSafeImagePathExtension);
 422
 423   base::PostTaskAndReplyWithResult(
 424       parent_->background_task_runner_,
 425       FROM_HERE,
 426       base::Bind(&SaveImage, user_image_, image_path_),
 427       base::Bind(&Job::OnSaveImageDone, weak_factory_.GetWeakPtr()));
 428 }
 429
 430 void UserImageManagerImpl::Job::OnSaveImageDone(bool success) {
 431   if (success || image_index_ == User::kProfileImageIndex)
 432     UpdateLocalState();
 433   NotifyJobDone();
 434 }
 435
 436 void UserImageManagerImpl::Job::UpdateLocalState() {
 437   // Ignore if data stored or cached outside the user's cryptohome is to be
 438   // treated as ephemeral.
 439   if (parent_->user_manager_->IsUserNonCryptohomeDataEphemeral(user_id()))
 440     return;
 441
 442   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
 443   entry->Set(kImagePathNodeName, new base::StringValue(image_path_.value()));
 444   entry->Set(kImageIndexNodeName, new base::FundamentalValue(image_index_));
 445   if (!image_url_.is_empty())
 446     entry->Set(kImageURLNodeName, new base::StringValue(image_url_.spec()));
 447   DictionaryPrefUpdate update(g_browser_process->local_state(),
 448                               kUserImageProperties);
 449   update->SetWithoutPathExpansion(user_id(), entry.release());
 450
 451   parent_->user_manager_->NotifyLocalStateChanged();
 452 }
 453
 454 void UserImageManagerImpl::Job::NotifyJobDone() {
 455   parent_->OnJobDone();
 456 }
 457
 458 UserImageManagerImpl::UserImageManagerImpl(const std::string& user_id,
 459                                            UserManager* user_manager)
 460     : UserImageManager(user_id),
 461       user_manager_(user_manager),
 462       downloading_profile_image_(false),
 463       profile_image_requested_(false),
 464       has_managed_image_(false),
 465       user_needs_migration_(false),
 466       weak_factory_(this) {
 467   base::SequencedWorkerPool* blocking_pool =
 468       content::BrowserThread::GetBlockingPool();
 469   background_task_runner_ =
 470       blocking_pool->GetSequencedTaskRunnerWithShutdownBehavior(
 471           blocking_pool->GetSequenceToken(),
 472           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 473   image_loader_ = new UserImageLoader(ImageDecoder::ROBUST_JPEG_CODEC,
 474                                       background_task_runner_);
 475   unsafe_image_loader_ = new UserImageLoader(ImageDecoder::DEFAULT_CODEC,
 476                                              background_task_runner_);
 477 }
 478
 479 UserImageManagerImpl::~UserImageManagerImpl() {}
 480
 481 void UserImageManagerImpl::LoadUserImage() {
 482   PrefService* local_state = g_browser_process->local_state();
 483   const base::DictionaryValue* prefs_images_unsafe =
 484       local_state->GetDictionary(kUserImages);
 485   const base::DictionaryValue* prefs_images =
 486       local_state->GetDictionary(kUserImageProperties);
 487   if (!prefs_images && !prefs_images_unsafe)
 488     return;
 489   User* user = GetUserAndModify();
 490   bool needs_migration = false;
 491
 492   // If entries are found in both |prefs_images_unsafe| and |prefs_images|,
 493   // |prefs_images| is honored for now but |prefs_images_unsafe| will be
 494   // migrated, overwriting the |prefs_images| entry, when the user logs in.
 495   const base::DictionaryValue* image_properties = NULL;
 496   if (prefs_images_unsafe) {
 497     needs_migration = prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
 498         user_id(), &image_properties);
 499     if (needs_migration)
 500       user_needs_migration_ = true;
 501   }
 502   if (prefs_images) {
 503     prefs_images->GetDictionaryWithoutPathExpansion(user_id(),
 504                                                     &image_properties);
 505   }
 506
 507   // If the user image for |user_id| is managed by policy and the policy-set
 508   // image is being loaded and persisted right now, let that job continue. It
 509   // will update the user image when done.
 510   if (IsUserImageManaged() && job_.get())
 511     return;
 512
 513   if (!image_properties) {
 514     SetInitialUserImage();
 515     return;
 516   }
 517
 518   int image_index = User::kInvalidImageIndex;
 519   image_properties->GetInteger(kImageIndexNodeName, &image_index);
 520   if (image_index >= 0 && image_index < kDefaultImagesCount) {
 521     user->SetImage(UserImage(GetDefaultImage(image_index)),
 522                    image_index);
 523     return;
 524   }
 525
 526   if (image_index != User::kExternalImageIndex &&
 527       image_index != User::kProfileImageIndex) {
 528     NOTREACHED();
 529     return;
 530   }
 531
 532   std::string image_url_string;
 533   image_properties->GetString(kImageURLNodeName, &image_url_string);
 534   GURL image_url(image_url_string);
 535   std::string image_path;
 536   image_properties->GetString(kImagePathNodeName, &image_path);
 537
 538   user->SetImageURL(image_url);
 539   user->SetStubImage(image_index, true);
 540   DCHECK(!image_path.empty() || image_index == User::kProfileImageIndex);
 541   if (image_path.empty() || needs_migration) {
 542     // Return if either of the following is true:
 543     // * The profile image is to be used but has not been downloaded yet. The
 544     //   profile image will be downloaded after login.
 545     // * The image needs migration. Migration will be performed after login.
 546     return;
 547   }
 548
 549   job_.reset(new Job(this));
 550   job_->LoadImage(base::FilePath(image_path), image_index, image_url);
 551 }
 552
 553 void UserImageManagerImpl::UserLoggedIn(bool user_is_new,
 554                                         bool user_is_local) {
 555   const User* user = GetUser();
 556   if (user_is_new) {
 557     if (!user_is_local)
 558       SetInitialUserImage();
 559   } else {
 560     UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
 561                               ImageIndexToHistogramIndex(user->image_index()),
 562                               kHistogramImagesCount);
 563
 564     if (!IsUserImageManaged() && user_needs_migration_) {
 565       const base::DictionaryValue* prefs_images_unsafe =
 566           g_browser_process->local_state()->GetDictionary(kUserImages);
 567       const base::DictionaryValue* image_properties = NULL;
 568       if (prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
 569               user_id(), &image_properties)) {
 570         std::string image_path;
 571         image_properties->GetString(kImagePathNodeName, &image_path);
 572         job_.reset(new Job(this));
 573         if (!image_path.empty()) {
 574           VLOG(0) << "Loading old user image, then migrating it.";
 575           job_->SetToPath(base::FilePath(image_path),
 576                           user->image_index(),
 577                           user->image_url(),
 578                           false);
 579         } else {
 580           job_->SetToDefaultImage(user->image_index());
 581         }
 582       }
 583     }
 584   }
 585
 586   // Reset the downloaded profile image as a new user logged in.
 587   downloaded_profile_image_ = gfx::ImageSkia();
 588   profile_image_url_ = GURL();
 589   profile_image_requested_ = false;
 590
 591   if (IsUserLoggedInAndRegular()) {
 592     TryToInitDownloadedProfileImage();
 593
 594     // Schedule an initial download of the profile data (full name and
 595     // optionally image).
 596     profile_download_one_shot_timer_.Start(
 597         FROM_HERE,
 598         g_ignore_profile_data_download_delay_ ?
 599             base::TimeDelta() :
 600             base::TimeDelta::FromSeconds(kProfileDataDownloadDelaySec),
 601         base::Bind(&UserImageManagerImpl::DownloadProfileData,
 602                    base::Unretained(this),
 603                    kProfileDownloadReasonLoggedIn));
 604     // Schedule periodic refreshes of the profile data.
 605     profile_download_periodic_timer_.Start(
 606         FROM_HERE,
 607         base::TimeDelta::FromSeconds(kProfileRefreshIntervalSec),
 608         base::Bind(&UserImageManagerImpl::DownloadProfileData,
 609                    base::Unretained(this),
 610                    kProfileDownloadReasonScheduled));
 611   } else {
 612     profile_download_one_shot_timer_.Stop();
 613     profile_download_periodic_timer_.Stop();
 614   }
 615
 616   user_image_sync_observer_.reset();
 617   TryToCreateImageSyncObserver();
 618 }
 619
 620 void UserImageManagerImpl::SaveUserDefaultImageIndex(int default_image_index) {
 621   if (IsUserImageManaged())
 622     return;
 623   job_.reset(new Job(this));
 624   job_->SetToDefaultImage(default_image_index);
 625 }
 626
 627 void UserImageManagerImpl::SaveUserImage(const UserImage& user_image) {
 628   if (IsUserImageManaged())
 629     return;
 630   job_.reset(new Job(this));
 631   job_->SetToImage(User::kExternalImageIndex, user_image);
 632 }
 633
 634 void UserImageManagerImpl::SaveUserImageFromFile(const base::FilePath& path) {
 635   if (IsUserImageManaged())
 636     return;
 637   job_.reset(new Job(this));
 638   job_->SetToPath(path, User::kExternalImageIndex, GURL(), true);
 639 }
 640
 641 void UserImageManagerImpl::SaveUserImageFromProfileImage() {
 642   if (IsUserImageManaged())
 643     return;
 644   // Use the profile image if it has been downloaded already. Otherwise, use a
 645   // stub image (gray avatar).
 646   job_.reset(new Job(this));
 647   job_->SetToImage(User::kProfileImageIndex,
 648                    downloaded_profile_image_.isNull() ?
 649                        UserImage() :
 650                        UserImage::CreateAndEncode(downloaded_profile_image_));
 651   // If no profile image has been downloaded yet, ensure that a download is
 652   // started.
 653   if (downloaded_profile_image_.isNull())
 654     DownloadProfileData(kProfileDownloadReasonProfileImageChosen);
 655 }
 656
 657 void UserImageManagerImpl::DeleteUserImage() {
 658   job_.reset();
 659   DeleteUserImageAndLocalStateEntry(kUserImages);
 660   DeleteUserImageAndLocalStateEntry(kUserImageProperties);
 661 }
 662
 663 void UserImageManagerImpl::DownloadProfileImage(const std::string& reason) {
 664   profile_image_requested_ = true;
 665   DownloadProfileData(reason);
 666 }
 667
 668 const gfx::ImageSkia& UserImageManagerImpl::DownloadedProfileImage() const {
 669   return downloaded_profile_image_;
 670 }
 671
 672 UserImageSyncObserver* UserImageManagerImpl::GetSyncObserver() const {
 673   return user_image_sync_observer_.get();
 674 }
 675
 676 void UserImageManagerImpl::Shutdown() {
 677   profile_downloader_.reset();
 678   user_image_sync_observer_.reset();
 679 }
 680
 681 void UserImageManagerImpl::OnExternalDataSet(const std::string& policy) {
 682   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
 683   if (IsUserImageManaged())
 684     return;
 685
 686   has_managed_image_ = true;
 687   job_.reset();
 688
 689   const User* user = GetUser();
 690   // If the user image for the currently logged-in user became managed, stop the
 691   // sync observer so that the policy-set image does not get synced out.
 692   if (user && user->is_logged_in())
 693     user_image_sync_observer_.reset();
 694 }
 695
 696 void UserImageManagerImpl::OnExternalDataCleared(const std::string& policy) {
 697   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
 698   has_managed_image_ = false;
 699   TryToCreateImageSyncObserver();
 700 }
 701
 702 void UserImageManagerImpl::OnExternalDataFetched(const std::string& policy,
 703                                                  scoped_ptr<std::string> data) {
 704   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
 705   DCHECK(IsUserImageManaged());
 706   if (data) {
 707     job_.reset(new Job(this));
 708     job_->SetToImageData(data.Pass());
 709   }
 710 }
 711
 712 // static
 713 void UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting() {
 714   g_ignore_profile_data_download_delay_ = true;
 715 }
 716
 717 bool UserImageManagerImpl::NeedsProfilePicture() const {
 718   return downloading_profile_image_;
 719 }
 720
 721 int UserImageManagerImpl::GetDesiredImageSideLength() const {
 722   return GetCurrentUserImageSize();
 723 }
 724
 725 Profile* UserImageManagerImpl::GetBrowserProfile() {
 726   return user_manager_->GetProfileByUser(GetUser());
 727 }
 728
 729 std::string UserImageManagerImpl::GetCachedPictureURL() const {
 730   return profile_image_url_.spec();
 731 }
 732
 733 void UserImageManagerImpl::OnProfileDownloadSuccess(
 734     ProfileDownloader* downloader) {
 735   // Ensure that the |profile_downloader_| is deleted when this method returns.
 736   scoped_ptr<ProfileDownloader> profile_downloader(
 737       profile_downloader_.release());
 738   DCHECK_EQ(downloader, profile_downloader.get());
 739
 740   user_manager_->UpdateUserAccountData(
 741       user_id(),
 742       UserManager::UserAccountData(downloader->GetProfileFullName(),
 743                                    downloader->GetProfileGivenName(),
 744                                    downloader->GetProfileLocale()));
 745   if (!downloading_profile_image_)
 746     return;
 747
 748   ProfileDownloadResult result = kDownloadFailure;
 749   switch (downloader->GetProfilePictureStatus()) {
 750     case ProfileDownloader::PICTURE_SUCCESS:
 751       result = kDownloadSuccess;
 752       break;
 753     case ProfileDownloader::PICTURE_CACHED:
 754       result = kDownloadCached;
 755       break;
 756     case ProfileDownloader::PICTURE_DEFAULT:
 757       result = kDownloadDefault;
 758       break;
 759     default:
 760       NOTREACHED();
 761   }
 762
 763   UMA_HISTOGRAM_ENUMERATION("UserImage.ProfileDownloadResult",
 764                             result,
 765                             kDownloadResultsCount);
 766   DCHECK(!profile_image_load_start_time_.is_null());
 767   AddProfileImageTimeHistogram(
 768       result,
 769       profile_image_download_reason_,
 770       base::TimeTicks::Now() - profile_image_load_start_time_);
 771
 772   // Ignore the image if it is no longer needed.
 773   if (!NeedProfileImage())
 774     return;
 775
 776   if (result == kDownloadDefault) {
 777     content::NotificationService::current()->Notify(
 778         chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
 779         content::Source<UserImageManager>(this),
 780         content::NotificationService::NoDetails());
 781   } else {
 782     profile_image_requested_ = false;
 783   }
 784
 785   // Nothing to do if the picture is cached or is the default avatar.
 786   if (result != kDownloadSuccess)
 787     return;
 788
 789   downloaded_profile_image_ = gfx::ImageSkia::CreateFrom1xBitmap(
 790       downloader->GetProfilePicture());
 791   profile_image_url_ = GURL(downloader->GetProfilePictureURL());
 792
 793   const User* user = GetUser();
 794   if (user->image_index() == User::kProfileImageIndex) {
 795     VLOG(1) << "Updating profile image for logged-in user.";
 796     UMA_HISTOGRAM_ENUMERATION("UserImage.ProfileDownloadResult",
 797                               kDownloadSuccessChanged,
 798                               kDownloadResultsCount);
 799     // This will persist |downloaded_profile_image_| to disk.
 800     SaveUserImageFromProfileImage();
 801   }
 802
 803   content::NotificationService::current()->Notify(
 804       chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED,
 805       content::Source<UserImageManager>(this),
 806       content::Details<const gfx::ImageSkia>(&downloaded_profile_image_));
 807 }
 808
 809 void UserImageManagerImpl::OnProfileDownloadFailure(
 810     ProfileDownloader* downloader,
 811     ProfileDownloaderDelegate::FailureReason reason) {
 812   DCHECK_EQ(downloader, profile_downloader_.get());
 813   profile_downloader_.reset();
 814
 815   if (downloading_profile_image_) {
 816     UMA_HISTOGRAM_ENUMERATION("UserImage.ProfileDownloadResult",
 817                               kDownloadFailure,
 818                               kDownloadResultsCount);
 819     DCHECK(!profile_image_load_start_time_.is_null());
 820     AddProfileImageTimeHistogram(
 821         kDownloadFailure,
 822         profile_image_download_reason_,
 823         base::TimeTicks::Now() - profile_image_load_start_time_);
 824   }
 825
 826   if (reason == ProfileDownloaderDelegate::NETWORK_ERROR) {
 827     // Retry download after a delay if a network error occurred.
 828     profile_download_one_shot_timer_.Start(
 829         FROM_HERE,
 830         base::TimeDelta::FromSeconds(kProfileDataDownloadRetryIntervalSec),
 831         base::Bind(&UserImageManagerImpl::DownloadProfileData,
 832                    base::Unretained(this),
 833                    kProfileDownloadReasonRetry));
 834   }
 835
 836   content::NotificationService::current()->Notify(
 837       chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
 838       content::Source<UserImageManager>(this),
 839       content::NotificationService::NoDetails());
 840 }
 841
 842 bool UserImageManagerImpl::IsUserImageManaged() const {
 843   return has_managed_image_;
 844 }
 845
 846 void UserImageManagerImpl::SetInitialUserImage() {
 847   // Choose a random default image.
 848   SaveUserDefaultImageIndex(base::RandInt(kFirstDefaultImageIndex,
 849                                           kDefaultImagesCount - 1));
 850 }
 851
 852 void UserImageManagerImpl::TryToInitDownloadedProfileImage() {
 853   const User* user = GetUser();
 854   if (user->image_index() == User::kProfileImageIndex &&
 855       downloaded_profile_image_.isNull() &&
 856       !user->image_is_stub()) {
 857     // Initialize the |downloaded_profile_image_| for the currently logged-in
 858     // user if it has not been initialized already, the user image is the
 859     // profile image and the user image has been loaded successfully.
 860     VLOG(1) << "Profile image initialized from disk.";
 861     downloaded_profile_image_ = user->GetImage();
 862     profile_image_url_ = user->image_url();
 863   }
 864 }
 865
 866 bool UserImageManagerImpl::NeedProfileImage() const {
 867   const User* user = GetUser();
 868   return IsUserLoggedInAndRegular() &&
 869       (user->image_index() == User::kProfileImageIndex ||
 870        profile_image_requested_);
 871 }
 872
 873 void UserImageManagerImpl::DownloadProfileData(const std::string& reason) {
 874   // GAIA profiles exist for regular users only.
 875   if (!IsUserLoggedInAndRegular())
 876     return;
 877
 878   // If a download is already in progress, allow it to continue, with one
 879   // exception: If the current download does not include the profile image but
 880   // the image has since become necessary, start a new download that includes
 881   // the profile image.
 882   if (profile_downloader_ &&
 883       (downloading_profile_image_ || !NeedProfileImage())) {
 884     return;
 885   }
 886
 887   downloading_profile_image_ = NeedProfileImage();
 888   profile_image_download_reason_ = reason;
 889   profile_image_load_start_time_ = base::TimeTicks::Now();
 890   profile_downloader_.reset(new ProfileDownloader(this));
 891   profile_downloader_->Start();
 892 }
 893
 894 void UserImageManagerImpl::DeleteUserImageAndLocalStateEntry(
 895     const char* prefs_dict_root) {
 896   DictionaryPrefUpdate update(g_browser_process->local_state(),
 897                               prefs_dict_root);
 898   const base::DictionaryValue* image_properties;
 899   if (!update->GetDictionaryWithoutPathExpansion(user_id(), &image_properties))
 900     return;
 901
 902   std::string image_path;
 903   image_properties->GetString(kImagePathNodeName, &image_path);
 904   if (!image_path.empty()) {
 905     background_task_runner_->PostTask(
 906         FROM_HERE,
 907         base::Bind(base::IgnoreResult(&base::DeleteFile),
 908                    base::FilePath(image_path),
 909                    false));
 910   }
 911   update->RemoveWithoutPathExpansion(user_id(), NULL);
 912 }
 913
 914 void UserImageManagerImpl::OnJobChangedUserImage() {
 915   if (GetUser()->is_logged_in())
 916     TryToInitDownloadedProfileImage();
 917
 918   content::NotificationService::current()->Notify(
 919       chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
 920       content::Source<UserImageManagerImpl>(this),
 921       content::Details<const User>(GetUser()));
 922 }
 923
 924 void UserImageManagerImpl::OnJobDone() {
 925   if (job_.get())
 926     base::MessageLoopProxy::current()->DeleteSoon(FROM_HERE, job_.release());
 927   else
 928     NOTREACHED();
 929
 930   if (!user_needs_migration_)
 931     return;
 932   // Migration completed for |user_id|.
 933   user_needs_migration_ = false;
 934
 935   const base::DictionaryValue* prefs_images_unsafe =
 936       g_browser_process->local_state()->GetDictionary(kUserImages);
 937   const base::DictionaryValue* image_properties = NULL;
 938   if (!prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
 939           user_id(), &image_properties)) {
 940     NOTREACHED();
 941     return;
 942   }
 943
 944   int image_index = User::kInvalidImageIndex;
 945   image_properties->GetInteger(kImageIndexNodeName, &image_index);
 946   UMA_HISTOGRAM_ENUMERATION("UserImage.Migration",
 947                             ImageIndexToHistogramIndex(image_index),
 948                             kHistogramImagesCount);
 949
 950   std::string image_path;
 951   image_properties->GetString(kImagePathNodeName, &image_path);
 952   if (!image_path.empty()) {
 953     // If an old image exists, delete it and remove |user_id| from the old prefs
 954     // dictionary only after the deletion has completed. This ensures that no
 955     // orphaned image is left behind if the browser crashes before the deletion
 956     // has been performed: In that case, local state will be unchanged and the
 957     // migration will be run again on the user's next login.
 958     background_task_runner_->PostTaskAndReply(
 959         FROM_HERE,
 960         base::Bind(base::IgnoreResult(&base::DeleteFile),
 961                    base::FilePath(image_path),
 962                    false),
 963         base::Bind(&UserImageManagerImpl::UpdateLocalStateAfterMigration,
 964                    weak_factory_.GetWeakPtr()));
 965   } else {
 966     // If no old image exists, remove |user_id| from the old prefs dictionary.
 967     UpdateLocalStateAfterMigration();
 968   }
 969 }
 970
 971 void UserImageManagerImpl::UpdateLocalStateAfterMigration() {
 972   DictionaryPrefUpdate update(g_browser_process->local_state(),
 973                               kUserImages);
 974   update->RemoveWithoutPathExpansion(user_id(), NULL);
 975 }
 976
 977 void UserImageManagerImpl::TryToCreateImageSyncObserver() {
 978   const User* user = GetUser();
 979   // If the currently logged-in user's user image is managed, the sync observer
 980   // must not be started so that the policy-set image does not get synced out.
 981   if (!user_image_sync_observer_ &&
 982       user && user->CanSyncImage() &&
 983       !IsUserImageManaged()) {
 984     user_image_sync_observer_.reset(new UserImageSyncObserver(user));
 985   }
 986 }
 987
 988 const User* UserImageManagerImpl::GetUser() const {
 989   return user_manager_->FindUser(user_id());
 990 }
 991
 992 User* UserImageManagerImpl::GetUserAndModify() const {
 993   return user_manager_->FindUserAndModify(user_id());
 994 }
 995
 996 bool UserImageManagerImpl::IsUserLoggedInAndRegular() const {
 997   const User* user = GetUser();
 998   if (!user)
 999     return false;
1000   return user->is_logged_in() && user->GetType() == User::USER_TYPE_REGULAR;
1001 }
1002
1003 }  // namespace chromeos