| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 286933002:
[cros login] Split login related classes into subfolders. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src