Rename WallpaperInfo::file --> WallpaperInfo::location.

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 
 #include <numeric>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 61 matching lines @@
 
 const int kCacheWallpaperDelayMs = 500;
 
 // A dictionary pref that maps usernames to wallpaper properties.
 const char kUserWallpapersProperties[] = "UserWallpapersProperties";
 
 // Names of nodes with info about wallpaper in |kUserWallpapersProperties|
 // dictionary.
 const char kNewWallpaperDateNodeName[] = "date";
 const char kNewWallpaperLayoutNodeName[] = "layout";
-const char kNewWallpaperFileNodeName[] = "file";
+const char kNewWallpaperLocationNodeName[] = "file";
 const char kNewWallpaperTypeNodeName[] = "type";
 
 // Maximum number of wallpapers cached by CacheUsersWallpapers().
 const int kMaxWallpapersToCache = 3;
 
 // Maximum number of entries in WallpaperManager::last_load_times_ .
 const size_t kLastLoadsStatsMsMaxSize = 4;
 
 // Minimum delay between wallpaper loads, milliseconds.
 const unsigned kLoadMinDelayMs = 50;
@@ skipping 296 matching lines @@
   } else if (!wallpaper_path_.empty()) {
     manager->task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                    user_id_,
                    info_,
                    wallpaper_path_,
                    true /* update wallpaper */,
                    base::Passed(on_finish_.Pass()),
                    manager->weak_factory_.GetWeakPtr()));
-  } else if (!info_.file.empty()) {
+  } else if (!info_.location.empty()) {
     manager->LoadWallpaper(user_id_, info_, true, on_finish_.Pass());
   } else {
     // PendingWallpaper was created and never initialized?
     NOTREACHED();
     // Error. Do not record time.
     started_load_at_ = base::Time();
   }
   on_finish_.reset();
 }
 
@@ skipping 150 matching lines @@
       logged_in_users_cache.insert(*it);
     }
   }
   wallpaper_cache_ = logged_in_users_cache;
 }
 
 bool WallpaperManager::GetLoggedInUserWallpaperInfo(WallpaperInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (UserManager::Get()->IsLoggedInAsStub()) {
-    info->file = current_user_wallpaper_info_.file = "";
+    info->location = current_user_wallpaper_info_.location = "";
     info->layout = current_user_wallpaper_info_.layout =
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type =
         user_manager::User::DEFAULT;
     info->date = current_user_wallpaper_info_.date =
         base::Time::Now().LocalMidnight();
     return true;
   }
 
   return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
@@ skipping 86 matching lines @@
   }
 }
 
 void WallpaperManager::RemoveUserWallpaperInfo(const std::string& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
-  DeleteUserWallpapers(user_id, info.file);
+  DeleteUserWallpapers(user_id, info.location);
 }
 
 // static
 bool WallpaperManager::ResizeImage(const gfx::ImageSkia& image,
                                    ash::WallpaperLayout layout,
                                    int preferred_width,
                                    int preferred_height,
                                    scoped_refptr<base::RefCountedBytes>* output,
                                    gfx::ImageSkia* output_skia) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 231 matching lines @@
     // that the user selected.
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
         BrowserThread::GetBlockingPool()
             ->GetSequencedTaskRunnerWithShutdownBehavior(
                 sequence_token_, base::SequencedWorkerPool::BLOCK_SHUTDOWN);
     // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
     blocking_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManager::SaveCustomWallpaper,
                    user_id_hash,
-                   base::FilePath(wallpaper_info.file),
+                   base::FilePath(wallpaper_info.location),
                    wallpaper_info.layout,
                    base::Passed(deep_copy.Pass())));
   }
 
   std::string relative_path = base::FilePath(user_id_hash).Append(file).value();
   // User's custom wallpaper path is determined by relative path and the
   // appropriate wallpaper resolution in GetCustomWallpaperInternal.
   WallpaperInfo info = {
       relative_path,
       layout,
@@ skipping 151 matching lines @@
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     base::WeakPtr<WallpaperManager> weak_ptr) {
 
   base::FilePath valid_path = wallpaper_path;
   if (!base::PathExists(wallpaper_path)) {
     // Falls back on original file if the correct resolution file does not
     // exist. This may happen when the original custom wallpaper is small or
     // browser shutdown before resized wallpaper saved.
     valid_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
-    valid_path = valid_path.Append(info.file);
+    valid_path = valid_path.Append(info.location);
   }
 
   if (!base::PathExists(valid_path)) {
     // Falls back to custom wallpaper that uses email as part of its file path.
     // Note that email is used instead of user_id_hash here.
-    valid_path =
-        GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id, info.file);
+    valid_path = GetCustomWallpaperPath(kOriginalWallpaperSubDir,
+                                        user_id, info.location);
   }
 
   if (!base::PathExists(valid_path)) {
     LOG(ERROR) << "Failed to load previously selected custom wallpaper. " <<
                   "Fallback to default wallpaper";
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::DoSetDefaultWallpaper,
                                        weak_ptr,
                                        user_id,
                                        base::Passed(on_finish.Pass())));
   } else {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::StartLoad,
                                        weak_ptr,
                                        user_id,
                                        info,
                                        update_wallpaper,
                                        valid_path,
                                        base::Passed(on_finish.Pass())));
   }
 }
 
 void WallpaperManager::InitInitialUserWallpaper(const std::string& user_id,
                                                 bool is_persistent) {
-  current_user_wallpaper_info_.file = "";
+  current_user_wallpaper_info_.location = "";
   current_user_wallpaper_info_.layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
   current_user_wallpaper_info_.type = user_manager::User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
   SetUserWallpaperInfo(user_id, info, is_persistent);
 }
 
 void WallpaperManager::SetUserWallpaperInfo(const std::string& user_id,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   current_user_wallpaper_info_ = info;
   if (!is_persistent)
     return;
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate wallpaper_update(local_state,
                                         prefs::kUsersWallpaperInfo);
 
   base::DictionaryValue* wallpaper_info_dict = new base::DictionaryValue();
   wallpaper_info_dict->SetString(kNewWallpaperDateNodeName,
       base::Int64ToString(info.date.ToInternalValue()));
-  wallpaper_info_dict->SetString(kNewWallpaperFileNodeName, info.file);
+  wallpaper_info_dict->SetString(kNewWallpaperLocationNodeName, info.location);
   wallpaper_info_dict->SetInteger(kNewWallpaperLayoutNodeName, info.layout);
   wallpaper_info_dict->SetInteger(kNewWallpaperTypeNodeName, info.type);
   wallpaper_update->SetWithoutPathExpansion(user_id, wallpaper_info_dict);
 }
 
 void WallpaperManager::SetUserWallpaperDelayed(const std::string& user_id) {
   ScheduleSetUserWallpaper(user_id, true);
 }
 
 void WallpaperManager::SetUserWallpaperNow(const std::string& user_id) {
@@ skipping 29 matching lines @@
     InitInitialUserWallpaper(user_id, true);
     GetUserWallpaperInfo(user_id, &info);
   }
 
   gfx::ImageSkia user_wallpaper;
   current_user_wallpaper_info_ = info;
   if (GetWallpaperFromCache(user_id, &user_wallpaper)) {
     GetPendingWallpaper(user_id, delayed)
         ->ResetSetWallpaperImage(user_wallpaper, info);
   } else {
-    if (info.file.empty()) {
+    if (info.location.empty()) {
       // Uses default built-in wallpaper when file is empty. Eventually, we
       // will only ship one built-in wallpaper in ChromeOS image.
       GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
       return;
     }
 
     if (info.type == user_manager::User::CUSTOMIZED ||
         info.type == user_manager::User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       // Wallpaper is not resized when layout is ash::WALLPAPER_LAYOUT_CENTER.
       // Original wallpaper should be used in this case.
       // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
       if (info.layout == ash::WALLPAPER_LAYOUT_CENTER)
         sub_dir = kOriginalWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
-      wallpaper_path = wallpaper_path.Append(info.file);
+      wallpaper_path = wallpaper_path.Append(info.location);
       if (current_wallpaper_path_ == wallpaper_path)
         return;
       current_wallpaper_path_ = wallpaper_path;
       loaded_wallpapers_++;
 
       GetPendingWallpaper(user_id, delayed)
           ->ResetSetCustomWallpaper(info, wallpaper_path);
       return;
     }
 
@@ skipping 78 matching lines @@
       CacheUserWallpaper(user_id);
     }
   }
 }
 
 void WallpaperManager::CacheUserWallpaper(const std::string& user_id) {
   if (wallpaper_cache_.find(user_id) != wallpaper_cache_.end())
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(user_id, &info)) {
-    if (info.file.empty())
+    if (info.location.empty())
       return;
 
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
     if (info.type == user_manager::User::CUSTOMIZED ||
         info.type == user_manager::User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
-      wallpaper_path = wallpaper_path.Append(info.file);
+      wallpaper_path = wallpaper_path.Append(info.location);
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
                      base::Passed(MovableOnDestroyCallbackHolder()),
                      weak_factory_.GetWeakPtr()));
       return;
@@ skipping 92 matching lines @@
 void WallpaperManager::LoadWallpaper(const std::string& user_id,
                                      const WallpaperInfo& info,
                                      bool update_wallpaper,
                                      MovableOnDestroyCallbackHolder on_finish) {
   base::FilePath wallpaper_dir;
   base::FilePath wallpaper_path;
 
   // Do a sanity check that file path information is not empty.
   if (info.type == user_manager::User::ONLINE ||
       info.type == user_manager::User::DEFAULT) {
-    if (info.file.empty()) {
+    if (info.location.empty()) {
       if (base::SysInfo::IsRunningOnChromeOS()) {
         NOTREACHED() << "User wallpaper info appears to be broken: " << user_id;
       } else {
         // Filename might be empty on debug configurations when stub users
         // were created directly in Local State (for testing). Ignore such
         // errors i.e. allowsuch type of debug configurations on the desktop.
         LOG(WARNING) << "User wallpaper info is empty: " << user_id;
 
         // |on_finish| callback will get called on destruction.
         return;
       }
     }
   }
 
   if (info.type == user_manager::User::ONLINE) {
-    std::string file_name = GURL(info.file).ExtractFileName();
+    std::string file_name = GURL(info.location).ExtractFileName();
     WallpaperResolution resolution = GetAppropriateResolution();
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
     if (info.layout != ash::WALLPAPER_LAYOUT_STRETCH &&
         resolution == WALLPAPER_RESOLUTION_SMALL) {
       file_name = base::FilePath(file_name).InsertBeforeExtension(
           kSmallWallpaperSuffix).value();
     }
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     wallpaper_path = wallpaper_dir.Append(file_name);
     if (current_wallpaper_path_ == wallpaper_path)
       return;
 
     if (update_wallpaper)
       current_wallpaper_path_ = wallpaper_path;
 
     loaded_wallpapers_++;
     StartLoad(
         user_id, info, update_wallpaper, wallpaper_path, on_finish.Pass());
   } else if (info.type == user_manager::User::DEFAULT) {
     // Default wallpapers are migrated from M21 user profiles. A code refactor
     // overlooked that case and caused these wallpapers not being loaded at all.
     // On some slow devices, it caused login webui not visible after upgrade to
     // M26 from M21. See crosbug.com/38429 for details.
     base::FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-    wallpaper_path = user_data_dir.Append(info.file);
+    wallpaper_path = user_data_dir.Append(info.location);
     StartLoad(
         user_id, info, update_wallpaper, wallpaper_path, on_finish.Pass());
   } else {
     // In unexpected cases, revert to default wallpaper to fail safely. See
     // crosbug.com/38429.
     LOG(ERROR) << "Wallpaper reverts to default unexpected.";
     DoSetDefaultWallpaper(user_id, on_finish.Pass());
   }
 }
 
@@ skipping 11 matching lines @@
   }
 
   const base::DictionaryValue* info_dict;
   if (!g_browser_process->local_state()->
           GetDictionary(prefs::kUsersWallpaperInfo)->
               GetDictionaryWithoutPathExpansion(user_id, &info_dict)) {
     return false;
   }
 
   // Use temporary variables to keep |info| untouched in the error case.
-  std::string file;
-  if (!info_dict->GetString(kNewWallpaperFileNodeName, &file))
+  std::string location;
+  if (!info_dict->GetString(kNewWallpaperLocationNodeName, &location))
     return false;
   int layout;
   if (!info_dict->GetInteger(kNewWallpaperLayoutNodeName, &layout))
     return false;
   int type;
   if (!info_dict->GetInteger(kNewWallpaperTypeNodeName, &type))
     return false;
   std::string date_string;
   if (!info_dict->GetString(kNewWallpaperDateNodeName, &date_string))
     return false;
   int64 date_val;
   if (!base::StringToInt64(date_string, &date_val))
     return false;
 
-  info->file = file;
+  info->location = location;
   info->layout = static_cast<ash::WallpaperLayout>(layout);
   info->type = static_cast<user_manager::User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
 void WallpaperManager::MoveCustomWallpapersSuccess(
     const std::string& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   if (info.type == user_manager::User::CUSTOMIZED) {
     // New file field should include user id hash in addition to file name.
     // This is needed because at login screen, user id hash is not available.
-    std::string relative_path =
-        base::FilePath(user_id_hash).Append(info.file).value();
-    info.file = relative_path;
+    info.location = base::FilePath(user_id_hash).Append(info.location).value();
     bool is_persistent =
         !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
   const user_manager::User* logged_in_user =
       UserManager::Get()->GetLoggedInUser();
   task_runner_->PostTask(
@@ skipping 373 matching lines @@
 void WallpaperManager::CreateSolidDefaultWallpaper() {
   loaded_wallpapers_++;
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(kDefaultWallpaperColor);
   const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
   default_wallpaper_image_.reset(new user_manager::UserImage(image));
 }
 
 }  // namespace chromeos