1 // Copyright (c) 2012 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/profiles/profile_info_cache.h" 6 7 #include "base/bind.h" 8 #include "base/file_util.h" 9 #include "base/format_macros.h" 10 #include "base/i18n/case_conversion.h" 11 #include "base/logging.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/prefs/pref_registry_simple.h" 14 #include "base/prefs/pref_service.h" 15 #include "base/rand_util.h" 16 #include "base/stl_util.h" 17 #include "base/strings/string_number_conversions.h" 18 #include "base/strings/string_piece.h" 19 #include "base/strings/stringprintf.h" 20 #include "base/strings/utf_string_conversions.h" 21 #include "base/values.h" 22 #include "chrome/browser/browser_process.h" 23 #include "chrome/browser/chrome_notification_types.h" 24 #include "chrome/browser/prefs/scoped_user_pref_update.h" 25 #include "chrome/common/pref_names.h" 26 #include "content/public/browser/browser_thread.h" 27 #include "content/public/browser/notification_service.h" 28 #include "grit/generated_resources.h" 29 #include "grit/theme_resources.h" 30 #include "third_party/skia/include/core/SkBitmap.h" 31 #include "ui/base/l10n/l10n_util.h" 32 #include "ui/base/resource/resource_bundle.h" 33 #include "ui/gfx/image/image.h" 34 #include "ui/gfx/image/image_util.h" 35 36 using content::BrowserThread; 37 38 namespace { 39 40 const char kNameKey[] = "name"; 41 const char kShortcutNameKey[] = "shortcut_name"; 42 const char kGAIANameKey[] = "gaia_name"; 43 const char kUseGAIANameKey[] = "use_gaia_name"; 44 const char kUserNameKey[] = "user_name"; 45 const char kAvatarIconKey[] = "avatar_icon"; 46 const char kUseGAIAPictureKey[] = "use_gaia_picture"; 47 const char kBackgroundAppsKey[] = "background_apps"; 48 const char kHasMigratedToGAIAInfoKey[] = "has_migrated_to_gaia_info"; 49 const char kGAIAPictureFileNameKey[] = "gaia_picture_file_name"; 50 const char kIsManagedKey[] = "is_managed"; 51 const char kSigninRequiredKey[] = "signin_required"; 52 const char kManagedUserId[] = "managed_user_id"; 53 54 const char kDefaultUrlPrefix[] = "chrome://theme/IDR_PROFILE_AVATAR_"; 55 const char kGAIAPictureFileName[] = "Google Profile Picture.png"; 56 57 const int kDefaultAvatarIconResources[] = { 58 IDR_PROFILE_AVATAR_0, 59 IDR_PROFILE_AVATAR_1, 60 IDR_PROFILE_AVATAR_2, 61 IDR_PROFILE_AVATAR_3, 62 IDR_PROFILE_AVATAR_4, 63 IDR_PROFILE_AVATAR_5, 64 IDR_PROFILE_AVATAR_6, 65 IDR_PROFILE_AVATAR_7, 66 IDR_PROFILE_AVATAR_8, 67 IDR_PROFILE_AVATAR_9, 68 IDR_PROFILE_AVATAR_10, 69 IDR_PROFILE_AVATAR_11, 70 IDR_PROFILE_AVATAR_12, 71 IDR_PROFILE_AVATAR_13, 72 IDR_PROFILE_AVATAR_14, 73 IDR_PROFILE_AVATAR_15, 74 IDR_PROFILE_AVATAR_16, 75 IDR_PROFILE_AVATAR_17, 76 IDR_PROFILE_AVATAR_18, 77 IDR_PROFILE_AVATAR_19, 78 IDR_PROFILE_AVATAR_20, 79 IDR_PROFILE_AVATAR_21, 80 IDR_PROFILE_AVATAR_22, 81 IDR_PROFILE_AVATAR_23, 82 IDR_PROFILE_AVATAR_24, 83 IDR_PROFILE_AVATAR_25, 84 }; 85 86 const size_t kDefaultAvatarIconsCount = arraysize(kDefaultAvatarIconResources); 87 88 // The first 8 icons are generic. 89 const size_t kGenericIconCount = 8; 90 91 // First eight are generic icons, which use IDS_NUMBERED_PROFILE_NAME. 92 const int kDefaultNames[] = { 93 IDS_DEFAULT_AVATAR_NAME_8, 94 IDS_DEFAULT_AVATAR_NAME_9, 95 IDS_DEFAULT_AVATAR_NAME_10, 96 IDS_DEFAULT_AVATAR_NAME_11, 97 IDS_DEFAULT_AVATAR_NAME_12, 98 IDS_DEFAULT_AVATAR_NAME_13, 99 IDS_DEFAULT_AVATAR_NAME_14, 100 IDS_DEFAULT_AVATAR_NAME_15, 101 IDS_DEFAULT_AVATAR_NAME_16, 102 IDS_DEFAULT_AVATAR_NAME_17, 103 IDS_DEFAULT_AVATAR_NAME_18, 104 IDS_DEFAULT_AVATAR_NAME_19, 105 IDS_DEFAULT_AVATAR_NAME_20, 106 IDS_DEFAULT_AVATAR_NAME_21, 107 IDS_DEFAULT_AVATAR_NAME_22, 108 IDS_DEFAULT_AVATAR_NAME_23, 109 IDS_DEFAULT_AVATAR_NAME_24, 110 IDS_DEFAULT_AVATAR_NAME_25 111 }; 112 113 typedef std::vector<unsigned char> ImageData; 114 115 // Writes |data| to disk and takes ownership of the pointer. On completion 116 // |success| is set to true on success and false on failure. 117 void SaveBitmap(ImageData* data, 118 const base::FilePath& image_path, 119 bool* success) { 120 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 121 scoped_ptr<ImageData> data_owner(data); 122 *success = false; 123 124 // Make sure the destination directory exists. 125 base::FilePath dir = image_path.DirName(); 126 if (!base::DirectoryExists(dir) && !file_util::CreateDirectory(dir)) { 127 LOG(ERROR) << "Failed to create parent directory."; 128 return; 129 } 130 131 if (file_util::WriteFile(image_path, 132 reinterpret_cast<char*>(&(*data)[0]), 133 data->size()) == -1) { 134 LOG(ERROR) << "Failed to save image to file."; 135 return; 136 } 137 138 *success = true; 139 } 140 141 // Reads a PNG from disk and decodes it. If the bitmap was successfully read 142 // from disk the then |out_image| will contain the bitmap image, otherwise it 143 // will be NULL. 144 void ReadBitmap(const base::FilePath& image_path, 145 gfx::Image** out_image) { 146 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 147 *out_image = NULL; 148 149 std::string image_data; 150 if (!file_util::ReadFileToString(image_path, &image_data)) { 151 LOG(ERROR) << "Failed to read PNG file from disk."; 152 return; 153 } 154 155 const unsigned char* data = 156 reinterpret_cast<const unsigned char*>(image_data.data()); 157 gfx::Image image = 158 gfx::Image::CreateFrom1xPNGBytes(data, image_data.length()); 159 if (image.IsEmpty()) { 160 LOG(ERROR) << "Failed to decode PNG file."; 161 return; 162 } 163 164 *out_image = new gfx::Image(image); 165 } 166 167 void DeleteBitmap(const base::FilePath& image_path) { 168 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 169 base::DeleteFile(image_path, false); 170 } 171 172 } // namespace 173 174 ProfileInfoCache::ProfileInfoCache(PrefService* prefs, 175 const base::FilePath& user_data_dir) 176 : prefs_(prefs), 177 user_data_dir_(user_data_dir) { 178 // Populate the cache 179 DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache); 180 DictionaryValue* cache = update.Get(); 181 for (DictionaryValue::Iterator it(*cache); !it.IsAtEnd(); it.Advance()) { 182 DictionaryValue* info = NULL; 183 cache->GetDictionaryWithoutPathExpansion(it.key(), &info); 184 string16 name; 185 info->GetString(kNameKey, &name); 186 sorted_keys_.insert(FindPositionForProfile(it.key(), name), it.key()); 187 // TODO(ibraaaa): delete this when we fully migrate to 188 // |prefs::kManagedUserId|. 189 bool is_managed = false; 190 info->GetBoolean(kIsManagedKey, &is_managed); 191 if (is_managed) { 192 info->SetString(kManagedUserId, "DUMMY_ID"); 193 info->Remove(kIsManagedKey, NULL); 194 } 195 } 196 } 197 198 ProfileInfoCache::~ProfileInfoCache() { 199 STLDeleteContainerPairSecondPointers( 200 gaia_pictures_.begin(), gaia_pictures_.end()); 201 } 202 203 void ProfileInfoCache::AddProfileToCache(const base::FilePath& profile_path, 204 const string16& name, 205 const string16& username, 206 size_t icon_index, 207 const std::string& managed_user_id) { 208 std::string key = CacheKeyFromProfilePath(profile_path); 209 DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache); 210 DictionaryValue* cache = update.Get(); 211 212 scoped_ptr<DictionaryValue> info(new DictionaryValue); 213 info->SetString(kNameKey, name); 214 info->SetString(kUserNameKey, username); 215 info->SetString(kAvatarIconKey, GetDefaultAvatarIconUrl(icon_index)); 216 // Default value for whether background apps are running is false. 217 info->SetBoolean(kBackgroundAppsKey, false); 218 info->SetString(kManagedUserId, managed_user_id); 219 cache->Set(key, info.release()); 220 221 sorted_keys_.insert(FindPositionForProfile(key, name), key); 222 223 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 224 observer_list_, 225 OnProfileAdded(profile_path)); 226 227 content::NotificationService::current()->Notify( 228 chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED, 229 content::NotificationService::AllSources(), 230 content::NotificationService::NoDetails()); 231 } 232 233 void ProfileInfoCache::AddObserver(ProfileInfoCacheObserver* obs) { 234 observer_list_.AddObserver(obs); 235 } 236 237 void ProfileInfoCache::RemoveObserver(ProfileInfoCacheObserver* obs) { 238 observer_list_.RemoveObserver(obs); 239 } 240 241 void ProfileInfoCache::DeleteProfileFromCache( 242 const base::FilePath& profile_path) { 243 size_t profile_index = GetIndexOfProfileWithPath(profile_path); 244 if (profile_index == std::string::npos) { 245 NOTREACHED(); 246 return; 247 } 248 string16 name = GetNameOfProfileAtIndex(profile_index); 249 250 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 251 observer_list_, 252 OnProfileWillBeRemoved(profile_path)); 253 254 DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache); 255 DictionaryValue* cache = update.Get(); 256 std::string key = CacheKeyFromProfilePath(profile_path); 257 cache->Remove(key, NULL); 258 sorted_keys_.erase(std::find(sorted_keys_.begin(), sorted_keys_.end(), key)); 259 260 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 261 observer_list_, 262 OnProfileWasRemoved(profile_path, name)); 263 264 content::NotificationService::current()->Notify( 265 chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED, 266 content::NotificationService::AllSources(), 267 content::NotificationService::NoDetails()); 268 } 269 270 size_t ProfileInfoCache::GetNumberOfProfiles() const { 271 return sorted_keys_.size(); 272 } 273 274 size_t ProfileInfoCache::GetIndexOfProfileWithPath( 275 const base::FilePath& profile_path) const { 276 if (profile_path.DirName() != user_data_dir_) 277 return std::string::npos; 278 std::string search_key = CacheKeyFromProfilePath(profile_path); 279 for (size_t i = 0; i < sorted_keys_.size(); ++i) { 280 if (sorted_keys_[i] == search_key) 281 return i; 282 } 283 return std::string::npos; 284 } 285 286 string16 ProfileInfoCache::GetNameOfProfileAtIndex(size_t index) const { 287 string16 name; 288 if (IsUsingGAIANameOfProfileAtIndex(index)) 289 name = GetGAIANameOfProfileAtIndex(index); 290 if (name.empty()) 291 GetInfoForProfileAtIndex(index)->GetString(kNameKey, &name); 292 return name; 293 } 294 295 string16 ProfileInfoCache::GetShortcutNameOfProfileAtIndex(size_t index) 296 const { 297 string16 shortcut_name; 298 GetInfoForProfileAtIndex(index)->GetString( 299 kShortcutNameKey, &shortcut_name); 300 return shortcut_name; 301 } 302 303 base::FilePath ProfileInfoCache::GetPathOfProfileAtIndex(size_t index) const { 304 return user_data_dir_.AppendASCII(sorted_keys_[index]); 305 } 306 307 string16 ProfileInfoCache::GetUserNameOfProfileAtIndex(size_t index) const { 308 string16 user_name; 309 GetInfoForProfileAtIndex(index)->GetString(kUserNameKey, &user_name); 310 return user_name; 311 } 312 313 const gfx::Image& ProfileInfoCache::GetAvatarIconOfProfileAtIndex( 314 size_t index) const { 315 if (IsUsingGAIAPictureOfProfileAtIndex(index)) { 316 const gfx::Image* image = GetGAIAPictureOfProfileAtIndex(index); 317 if (image) 318 return *image; 319 } 320 321 int resource_id = GetDefaultAvatarIconResourceIDAtIndex( 322 GetAvatarIconIndexOfProfileAtIndex(index)); 323 return ResourceBundle::GetSharedInstance().GetNativeImageNamed(resource_id); 324 } 325 326 bool ProfileInfoCache::GetBackgroundStatusOfProfileAtIndex( 327 size_t index) const { 328 bool background_app_status; 329 if (!GetInfoForProfileAtIndex(index)->GetBoolean(kBackgroundAppsKey, 330 &background_app_status)) { 331 return false; 332 } 333 return background_app_status; 334 } 335 336 string16 ProfileInfoCache::GetGAIANameOfProfileAtIndex(size_t index) const { 337 string16 name; 338 GetInfoForProfileAtIndex(index)->GetString(kGAIANameKey, &name); 339 return name; 340 } 341 342 bool ProfileInfoCache::IsUsingGAIANameOfProfileAtIndex(size_t index) const { 343 bool value = false; 344 GetInfoForProfileAtIndex(index)->GetBoolean(kUseGAIANameKey, &value); 345 return value; 346 } 347 348 const gfx::Image* ProfileInfoCache::GetGAIAPictureOfProfileAtIndex( 349 size_t index) const { 350 base::FilePath path = GetPathOfProfileAtIndex(index); 351 std::string key = CacheKeyFromProfilePath(path); 352 353 // If the picture is already loaded then use it. 354 if (gaia_pictures_.count(key)) { 355 if (gaia_pictures_[key]->IsEmpty()) 356 return NULL; 357 return gaia_pictures_[key]; 358 } 359 360 std::string file_name; 361 GetInfoForProfileAtIndex(index)->GetString( 362 kGAIAPictureFileNameKey, &file_name); 363 364 // If the picture is not on disk or it is already being loaded then return 365 // NULL. 366 if (file_name.empty() || gaia_pictures_loading_[key]) 367 return NULL; 368 369 gaia_pictures_loading_[key] = true; 370 base::FilePath image_path = path.AppendASCII(file_name); 371 gfx::Image** image = new gfx::Image*; 372 BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE, 373 base::Bind(&ReadBitmap, image_path, image), 374 base::Bind(&ProfileInfoCache::OnGAIAPictureLoaded, 375 const_cast<ProfileInfoCache*>(this)->AsWeakPtr(), path, image)); 376 377 return NULL; 378 } 379 380 bool ProfileInfoCache::ProfileIsManagedAtIndex(size_t index) const { 381 return !GetManagedUserIdOfProfileAtIndex(index).empty(); 382 } 383 384 bool ProfileInfoCache::ProfileIsSigninRequiredAtIndex(size_t index) const { 385 bool value = false; 386 GetInfoForProfileAtIndex(index)->GetBoolean(kSigninRequiredKey, &value); 387 return value; 388 } 389 390 std::string ProfileInfoCache::GetManagedUserIdOfProfileAtIndex( 391 size_t index) const { 392 std::string managed_user_id; 393 GetInfoForProfileAtIndex(index)->GetString(kManagedUserId, &managed_user_id); 394 return managed_user_id; 395 } 396 397 void ProfileInfoCache::OnGAIAPictureLoaded(const base::FilePath& path, 398 gfx::Image** image) const { 399 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 400 401 std::string key = CacheKeyFromProfilePath(path); 402 gaia_pictures_loading_[key] = false; 403 404 if (*image) { 405 delete gaia_pictures_[key]; 406 gaia_pictures_[key] = *image; 407 } else { 408 // Place an empty image in the cache to avoid reloading it again. 409 gaia_pictures_[key] = new gfx::Image(); 410 } 411 delete image; 412 413 content::NotificationService::current()->Notify( 414 chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED, 415 content::NotificationService::AllSources(), 416 content::NotificationService::NoDetails()); 417 } 418 419 void ProfileInfoCache::OnGAIAPictureSaved(const base::FilePath& path, 420 bool* success) const { 421 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 422 423 if (*success) { 424 content::NotificationService::current()->Notify( 425 chrome::NOTIFICATION_PROFILE_CACHE_PICTURE_SAVED, 426 content::NotificationService::AllSources(), 427 content::NotificationService::NoDetails()); 428 } 429 delete success; 430 } 431 432 bool ProfileInfoCache::IsUsingGAIAPictureOfProfileAtIndex( 433 size_t index) const { 434 bool value = false; 435 GetInfoForProfileAtIndex(index)->GetBoolean(kUseGAIAPictureKey, &value); 436 return value; 437 } 438 439 size_t ProfileInfoCache::GetAvatarIconIndexOfProfileAtIndex(size_t index) 440 const { 441 std::string icon_url; 442 GetInfoForProfileAtIndex(index)->GetString(kAvatarIconKey, &icon_url); 443 size_t icon_index = 0; 444 if (IsDefaultAvatarIconUrl(icon_url, &icon_index)) 445 return icon_index; 446 447 DLOG(WARNING) << "Unknown avatar icon: " << icon_url; 448 return GetDefaultAvatarIconResourceIDAtIndex(0); 449 } 450 451 void ProfileInfoCache::SetNameOfProfileAtIndex(size_t index, 452 const string16& name) { 453 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 454 string16 current_name; 455 info->GetString(kNameKey, ¤t_name); 456 if (name == current_name) 457 return; 458 459 string16 old_display_name = GetNameOfProfileAtIndex(index); 460 info->SetString(kNameKey, name); 461 // This takes ownership of |info|. 462 SetInfoForProfileAtIndex(index, info.release()); 463 string16 new_display_name = GetNameOfProfileAtIndex(index); 464 base::FilePath profile_path = GetPathOfProfileAtIndex(index); 465 UpdateSortForProfileIndex(index); 466 467 if (old_display_name != new_display_name) { 468 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 469 observer_list_, 470 OnProfileNameChanged(profile_path, old_display_name)); 471 } 472 } 473 474 void ProfileInfoCache::SetShortcutNameOfProfileAtIndex( 475 size_t index, 476 const string16& shortcut_name) { 477 if (shortcut_name == GetShortcutNameOfProfileAtIndex(index)) 478 return; 479 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 480 info->SetString(kShortcutNameKey, shortcut_name); 481 // This takes ownership of |info|. 482 SetInfoForProfileAtIndex(index, info.release()); 483 } 484 485 void ProfileInfoCache::SetUserNameOfProfileAtIndex(size_t index, 486 const string16& user_name) { 487 if (user_name == GetUserNameOfProfileAtIndex(index)) 488 return; 489 490 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 491 info->SetString(kUserNameKey, user_name); 492 // This takes ownership of |info|. 493 SetInfoForProfileAtIndex(index, info.release()); 494 } 495 496 void ProfileInfoCache::SetAvatarIconOfProfileAtIndex(size_t index, 497 size_t icon_index) { 498 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 499 info->SetString(kAvatarIconKey, GetDefaultAvatarIconUrl(icon_index)); 500 // This takes ownership of |info|. 501 SetInfoForProfileAtIndex(index, info.release()); 502 503 base::FilePath profile_path = GetPathOfProfileAtIndex(index); 504 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 505 observer_list_, 506 OnProfileAvatarChanged(profile_path)); 507 } 508 509 void ProfileInfoCache::SetManagedUserIdOfProfileAtIndex(size_t index, 510 const std::string& id) { 511 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 512 info->SetString(kManagedUserId, id); 513 // This takes ownership of |info|. 514 SetInfoForProfileAtIndex(index, info.release()); 515 } 516 517 void ProfileInfoCache::SetBackgroundStatusOfProfileAtIndex( 518 size_t index, 519 bool running_background_apps) { 520 if (GetBackgroundStatusOfProfileAtIndex(index) == running_background_apps) 521 return; 522 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 523 info->SetBoolean(kBackgroundAppsKey, running_background_apps); 524 // This takes ownership of |info|. 525 SetInfoForProfileAtIndex(index, info.release()); 526 } 527 528 void ProfileInfoCache::SetGAIANameOfProfileAtIndex(size_t index, 529 const string16& name) { 530 if (name == GetGAIANameOfProfileAtIndex(index)) 531 return; 532 533 string16 old_display_name = GetNameOfProfileAtIndex(index); 534 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 535 info->SetString(kGAIANameKey, name); 536 // This takes ownership of |info|. 537 SetInfoForProfileAtIndex(index, info.release()); 538 string16 new_display_name = GetNameOfProfileAtIndex(index); 539 base::FilePath profile_path = GetPathOfProfileAtIndex(index); 540 UpdateSortForProfileIndex(index); 541 542 if (old_display_name != new_display_name) { 543 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 544 observer_list_, 545 OnProfileNameChanged(profile_path, old_display_name)); 546 } 547 } 548 549 void ProfileInfoCache::SetIsUsingGAIANameOfProfileAtIndex(size_t index, 550 bool value) { 551 if (value == IsUsingGAIANameOfProfileAtIndex(index)) 552 return; 553 554 string16 old_display_name = GetNameOfProfileAtIndex(index); 555 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 556 info->SetBoolean(kUseGAIANameKey, value); 557 // This takes ownership of |info|. 558 SetInfoForProfileAtIndex(index, info.release()); 559 string16 new_display_name = GetNameOfProfileAtIndex(index); 560 base::FilePath profile_path = GetPathOfProfileAtIndex(index); 561 UpdateSortForProfileIndex(index); 562 563 if (old_display_name != new_display_name) { 564 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 565 observer_list_, 566 OnProfileNameChanged(profile_path, old_display_name)); 567 } 568 } 569 570 void ProfileInfoCache::SetGAIAPictureOfProfileAtIndex(size_t index, 571 const gfx::Image* image) { 572 base::FilePath path = GetPathOfProfileAtIndex(index); 573 std::string key = CacheKeyFromProfilePath(path); 574 575 // Delete the old bitmap from cache. 576 std::map<std::string, gfx::Image*>::iterator it = gaia_pictures_.find(key); 577 if (it != gaia_pictures_.end()) { 578 delete it->second; 579 gaia_pictures_.erase(it); 580 } 581 582 std::string old_file_name; 583 GetInfoForProfileAtIndex(index)->GetString( 584 kGAIAPictureFileNameKey, &old_file_name); 585 std::string new_file_name; 586 587 if (!image) { 588 // Delete the old bitmap from disk. 589 if (!old_file_name.empty()) { 590 base::FilePath image_path = path.AppendASCII(old_file_name); 591 BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, 592 base::Bind(&DeleteBitmap, image_path)); 593 } 594 } else { 595 // Save the new bitmap to disk. 596 gaia_pictures_[key] = new gfx::Image(*image); 597 scoped_ptr<ImageData> data(new ImageData); 598 scoped_refptr<base::RefCountedMemory> png_data = image->As1xPNGBytes(); 599 data->assign(png_data->front(), png_data->front() + png_data->size()); 600 if (!data->size()) { 601 LOG(ERROR) << "Failed to PNG encode the image."; 602 } else { 603 new_file_name = 604 old_file_name.empty() ? kGAIAPictureFileName : old_file_name; 605 base::FilePath image_path = path.AppendASCII(new_file_name); 606 bool* success = new bool; 607 BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE, 608 base::Bind(&SaveBitmap, data.release(), image_path, success), 609 base::Bind(&ProfileInfoCache::OnGAIAPictureSaved, AsWeakPtr(), 610 path, success)); 611 } 612 } 613 614 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 615 info->SetString(kGAIAPictureFileNameKey, new_file_name); 616 // This takes ownership of |info|. 617 SetInfoForProfileAtIndex(index, info.release()); 618 619 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 620 observer_list_, 621 OnProfileAvatarChanged(path)); 622 } 623 624 void ProfileInfoCache::SetIsUsingGAIAPictureOfProfileAtIndex(size_t index, 625 bool value) { 626 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 627 info->SetBoolean(kUseGAIAPictureKey, value); 628 // This takes ownership of |info|. 629 SetInfoForProfileAtIndex(index, info.release()); 630 631 // Retrieve some info to update observers who care about avatar changes. 632 base::FilePath profile_path = GetPathOfProfileAtIndex(index); 633 FOR_EACH_OBSERVER(ProfileInfoCacheObserver, 634 observer_list_, 635 OnProfileAvatarChanged(profile_path)); 636 } 637 638 void ProfileInfoCache::SetProfileSigninRequiredAtIndex(size_t index, 639 bool value) { 640 if (value == ProfileIsSigninRequiredAtIndex(index)) 641 return; 642 643 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 644 info->SetBoolean(kSigninRequiredKey, value); 645 // This takes ownership of |info|. 646 SetInfoForProfileAtIndex(index, info.release()); 647 } 648 649 string16 ProfileInfoCache::ChooseNameForNewProfile(size_t icon_index) const { 650 string16 name; 651 for (int name_index = 1; ; ++name_index) { 652 if (icon_index < kGenericIconCount) { 653 name = l10n_util::GetStringFUTF16Int(IDS_NUMBERED_PROFILE_NAME, 654 name_index); 655 } else { 656 name = l10n_util::GetStringUTF16( 657 kDefaultNames[icon_index - kGenericIconCount]); 658 if (name_index > 1) 659 name.append(UTF8ToUTF16(base::IntToString(name_index))); 660 } 661 662 // Loop through previously named profiles to ensure we're not duplicating. 663 bool name_found = false; 664 for (size_t i = 0; i < GetNumberOfProfiles(); ++i) { 665 if (GetNameOfProfileAtIndex(i) == name) { 666 name_found = true; 667 break; 668 } 669 } 670 if (!name_found) 671 return name; 672 } 673 } 674 675 bool ProfileInfoCache::GetHasMigratedToGAIAInfoOfProfileAtIndex( 676 size_t index) const { 677 bool value = false; 678 GetInfoForProfileAtIndex(index)->GetBoolean( 679 kHasMigratedToGAIAInfoKey, &value); 680 return value; 681 } 682 683 void ProfileInfoCache::SetHasMigratedToGAIAInfoOfProfileAtIndex( 684 size_t index, bool value) { 685 scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy()); 686 info->SetBoolean(kHasMigratedToGAIAInfoKey, value); 687 // This takes ownership of |info|. 688 SetInfoForProfileAtIndex(index, info.release()); 689 } 690 691 bool ProfileInfoCache::IconIndexIsUnique(size_t icon_index) const { 692 for (size_t i = 0; i < GetNumberOfProfiles(); ++i) { 693 if (GetAvatarIconIndexOfProfileAtIndex(i) == icon_index) 694 return false; 695 } 696 return true; 697 } 698 699 bool ProfileInfoCache::ChooseAvatarIconIndexForNewProfile( 700 bool allow_generic_icon, 701 bool must_be_unique, 702 size_t* out_icon_index) const { 703 size_t start = allow_generic_icon ? 0 : kGenericIconCount; 704 size_t end = GetDefaultAvatarIconCount(); 705 size_t count = end - start; 706 707 int rand = base::RandInt(0, count); 708 for (size_t i = 0; i < count; ++i) { 709 size_t icon_index = start + (rand + i) % count; 710 if (!must_be_unique || IconIndexIsUnique(icon_index)) { 711 *out_icon_index = icon_index; 712 return true; 713 } 714 } 715 716 return false; 717 } 718 719 size_t ProfileInfoCache::ChooseAvatarIconIndexForNewProfile() const { 720 size_t icon_index = 0; 721 // Try to find a unique, non-generic icon. 722 if (ChooseAvatarIconIndexForNewProfile(false, true, &icon_index)) 723 return icon_index; 724 // Try to find any unique icon. 725 if (ChooseAvatarIconIndexForNewProfile(true, true, &icon_index)) 726 return icon_index; 727 // Settle for any random icon, even if it's not unique. 728 if (ChooseAvatarIconIndexForNewProfile(true, false, &icon_index)) 729 return icon_index; 730 731 NOTREACHED(); 732 return 0; 733 } 734 735 const base::FilePath& ProfileInfoCache::GetUserDataDir() const { 736 return user_data_dir_; 737 } 738 739 // static 740 size_t ProfileInfoCache::GetDefaultAvatarIconCount() { 741 return kDefaultAvatarIconsCount; 742 } 743 744 // static 745 int ProfileInfoCache::GetDefaultAvatarIconResourceIDAtIndex(size_t index) { 746 DCHECK(IsDefaultAvatarIconIndex(index)); 747 return kDefaultAvatarIconResources[index]; 748 } 749 750 // static 751 std::string ProfileInfoCache::GetDefaultAvatarIconUrl(size_t index) { 752 DCHECK(IsDefaultAvatarIconIndex(index)); 753 return base::StringPrintf("%s%" PRIuS, kDefaultUrlPrefix, index); 754 } 755 756 // static 757 bool ProfileInfoCache::IsDefaultAvatarIconIndex(size_t index) { 758 return index < kDefaultAvatarIconsCount; 759 } 760 761 // static 762 bool ProfileInfoCache::IsDefaultAvatarIconUrl(const std::string& url, 763 size_t* icon_index) { 764 DCHECK(icon_index); 765 if (url.find(kDefaultUrlPrefix) != 0) 766 return false; 767 768 int int_value = -1; 769 if (base::StringToInt(base::StringPiece(url.begin() + 770 strlen(kDefaultUrlPrefix), 771 url.end()), 772 &int_value)) { 773 if (int_value < 0 || 774 int_value >= static_cast<int>(kDefaultAvatarIconsCount)) 775 return false; 776 *icon_index = int_value; 777 return true; 778 } 779 780 return false; 781 } 782 783 const DictionaryValue* ProfileInfoCache::GetInfoForProfileAtIndex( 784 size_t index) const { 785 DCHECK_LT(index, GetNumberOfProfiles()); 786 const DictionaryValue* cache = 787 prefs_->GetDictionary(prefs::kProfileInfoCache); 788 const DictionaryValue* info = NULL; 789 cache->GetDictionary(sorted_keys_[index], &info); 790 return info; 791 } 792 793 void ProfileInfoCache::SetInfoForProfileAtIndex(size_t index, 794 DictionaryValue* info) { 795 DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache); 796 DictionaryValue* cache = update.Get(); 797 cache->Set(sorted_keys_[index], info); 798 799 content::NotificationService::current()->Notify( 800 chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED, 801 content::NotificationService::AllSources(), 802 content::NotificationService::NoDetails()); 803 } 804 805 std::string ProfileInfoCache::CacheKeyFromProfilePath( 806 const base::FilePath& profile_path) const { 807 DCHECK(user_data_dir_ == profile_path.DirName()); 808 base::FilePath base_name = profile_path.BaseName(); 809 return base_name.MaybeAsASCII(); 810 } 811 812 std::vector<std::string>::iterator ProfileInfoCache::FindPositionForProfile( 813 const std::string& search_key, 814 const string16& search_name) { 815 string16 search_name_l = base::i18n::ToLower(search_name); 816 for (size_t i = 0; i < GetNumberOfProfiles(); ++i) { 817 string16 name_l = base::i18n::ToLower(GetNameOfProfileAtIndex(i)); 818 int name_compare = search_name_l.compare(name_l); 819 if (name_compare < 0) 820 return sorted_keys_.begin() + i; 821 if (name_compare == 0) { 822 int key_compare = search_key.compare(sorted_keys_[i]); 823 if (key_compare < 0) 824 return sorted_keys_.begin() + i; 825 } 826 } 827 return sorted_keys_.end(); 828 } 829 830 void ProfileInfoCache::UpdateSortForProfileIndex(size_t index) { 831 string16 name = GetNameOfProfileAtIndex(index); 832 833 // Remove and reinsert key in |sorted_keys_| to alphasort. 834 std::string key = CacheKeyFromProfilePath(GetPathOfProfileAtIndex(index)); 835 std::vector<std::string>::iterator key_it = 836 std::find(sorted_keys_.begin(), sorted_keys_.end(), key); 837 DCHECK(key_it != sorted_keys_.end()); 838 sorted_keys_.erase(key_it); 839 sorted_keys_.insert(FindPositionForProfile(key, name), key); 840 841 content::NotificationService::current()->Notify( 842 chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED, 843 content::NotificationService::AllSources(), 844 content::NotificationService::NoDetails()); 845 } 846 847 // static 848 std::vector<string16> ProfileInfoCache::GetProfileNames() { 849 std::vector<string16> names; 850 PrefService* local_state = g_browser_process->local_state(); 851 const DictionaryValue* cache = local_state->GetDictionary( 852 prefs::kProfileInfoCache); 853 string16 name; 854 for (base::DictionaryValue::Iterator it(*cache); !it.IsAtEnd(); 855 it.Advance()) { 856 const base::DictionaryValue* info = NULL; 857 it.value().GetAsDictionary(&info); 858 info->GetString(kNameKey, &name); 859 names.push_back(name); 860 } 861 return names; 862 } 863 864 // static 865 void ProfileInfoCache::RegisterPrefs(PrefRegistrySimple* registry) { 866 registry->RegisterDictionaryPref(prefs::kProfileInfoCache); 867 } 868