[Chrome OS] Implement the device wallpaper policy.

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 <utility>
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/wallpaper/wallpaper_controller.h"
 #include "ash/common/wm_shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/path_service.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/customization/customization_document.h"
 #include "chrome/browser/chromeos/extensions/wallpaper_manager_util.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_loader.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/image_decoder.h"
 #include "chrome/browser/ui/ash/ash_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/known_user.h"
 #include "components/user_manager/user_names.h"
 #include "components/user_manager/user_type.h"
 #include "components/wallpaper/wallpaper_files_id.h"
 #include "components/wallpaper/wallpaper_layout.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_manager_connection.h"
+#include "crypto/sha2.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "url/gurl.h"
 
 using content::BrowserThread;
 using wallpaper::WallpaperManagerBase;
 using wallpaper::WallpaperInfo;
 using wallpaper::MovableOnDestroyCallback;
 using wallpaper::MovableOnDestroyCallbackHolder;
 
 namespace chromeos {
 
 namespace {
 
 WallpaperManager* wallpaper_manager = nullptr;
 
 // The amount of delay before starts to move custom wallpapers to the new place.
 const int kMoveCustomWallpaperDelaySeconds = 30;
 
 const int kCacheWallpaperDelayMs = 500;
 
 // Names of nodes with info about wallpaper in |kUserWallpapersProperties|
 // dictionary.
 const char kNewWallpaperDateNodeName[] = "date";
 const char kNewWallpaperLayoutNodeName[] = "layout";
 const char kNewWallpaperLocationNodeName[] = "file";
 const char kNewWallpaperTypeNodeName[] = "type";
 
 // Known user keys.
 const char kWallpaperFilesId[] = "wallpaper-files-id";
 
+// The directory and file name to save the downloaded device policy controlled
+// wallpaper.
+const char kDeviceWallpaperDir[] = "device_wallpaper";
+const char kDeviceWallpaperFile[] = "device_wallpaper_image.jpg";
+
 // These global default values are used to set customized default
 // wallpaper path in WallpaperManager::InitializeWallpaper().
 base::FilePath GetCustomizedWallpaperDefaultRescaledFileName(
     const std::string& suffix) {
   const base::FilePath default_downloaded_file_name =
       ServicesCustomizationDocument::GetCustomizedWallpaperDownloadedFileName();
   const base::FilePath default_cache_dir =
       ServicesCustomizationDocument::GetCustomizedWallpaperCacheDir();
   if (default_downloaded_file_name.empty() || default_cache_dir.empty())
     return base::FilePath();
@@ skipping 97 matching lines @@
     // large bitmaps over Mojo; use shared memory like BitmapUploader, etc.
     wallpaper_controller->SetWallpaper(*image.bitmap(), layout);
   } else if (ash::WmShell::HasInstance()) {
     // Note: Wallpaper setting is skipped in unit tests without shell instances.
     // In classic ash, interact with the WallpaperController class directly.
     ash::WmShell::Get()->wallpaper_controller()->SetWallpaperImage(image,
                                                                    layout);
   }
 }
 
+// A helper function to check the existing/downloaded device wallpaper file's
+// hash value matches with the hash value provided in the policy settings.
+bool CheckDeviceWallpaperMatchHash(const base::FilePath& device_wallpaper_file,
+                                   const std::string& hash) {
+  std::string image_data;
+  if (base::ReadFileToString(device_wallpaper_file, &image_data)) {
+    std::string sha_hash = crypto::SHA256HashString(image_data);
+    if (base::ToLowerASCII(base::HexEncode(
+            sha_hash.c_str(), sha_hash.size())) == base::ToLowerASCII(hash)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 // This is "wallpaper either scheduled to load, or loading right now".
 //
 // While enqueued, it defines moment in the future, when it will be loaded.
 // Enqueued but not started request might be updated by subsequent load
 // request. Therefore it's created empty, and updated being enqueued.
 //
 // PendingWallpaper is owned by WallpaperManager, but reference to this object
 // is passed to other threads by PostTask() calls, therefore it is
@@ skipping 132 matching lines @@
   // Load start time to calculate duration.
   base::Time started_load_at_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingWallpaper);
 };
 
 // WallpaperManager, public: ---------------------------------------------------
 
 WallpaperManager::~WallpaperManager() {
   show_user_name_on_signin_subscription_.reset();
+  device_wallpaper_image_subscription_.reset();
   user_manager::UserManager::Get()->RemoveSessionStateObserver(this);
   weak_factory_.InvalidateWeakPtrs();
 }
 
 // static
 void WallpaperManager::Initialize() {
   CHECK(!wallpaper_manager);
   wallpaper_manager = new WallpaperManager();
 }
 
@@ skipping 19 matching lines @@
              ? WALLPAPER_RESOLUTION_LARGE
              : WALLPAPER_RESOLUTION_SMALL;
 }
 
 void WallpaperManager::AddObservers() {
   show_user_name_on_signin_subscription_ =
       CrosSettings::Get()->AddSettingsObserver(
           kAccountsPrefShowUserNamesOnSignIn,
           base::Bind(&WallpaperManager::InitializeRegisteredDeviceWallpaper,
                      weak_factory_.GetWeakPtr()));
+  device_wallpaper_image_subscription_ =
+      CrosSettings::Get()->AddSettingsObserver(
+          kDeviceWallpaperImage,
+          base::Bind(&WallpaperManager::OnDeviceWallpaperPolicyChanged,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::EnsureLoggedInUserWallpaperLoaded() {
   WallpaperInfo info;
   if (GetLoggedInUserWallpaperInfo(&info)) {
     UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", info.type,
                               user_manager::User::WALLPAPER_TYPE_COUNT);
     if (info == current_user_wallpaper_info_)
       return;
   }
@@ skipping 291 matching lines @@
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
 
   // User is unknown or there is no visible wallpaper in kiosk mode.
   if (!user || user->GetType() == user_manager::USER_TYPE_KIOSK_APP ||
       user->GetType() == user_manager::USER_TYPE_ARC_KIOSK_APP) {
     return;
   }
 
+  // For a enterprise managed user, set the device wallpaper if we're at the
+  // login screen.
+  if (!user_manager::UserManager::Get()->IsUserLoggedIn() &&
+      SetDeviceWallpaperIfApplicable(account_id))
+    return;
+
   // Guest user or regular user in ephemeral mode.
   if ((user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
            account_id) &&
        user->HasGaiaAccount()) ||
       user->GetType() == user_manager::USER_TYPE_GUEST) {
     InitInitialUserWallpaper(account_id, false);
     GetPendingWallpaper(account_id, delayed)->ResetSetDefaultWallpaper();
     if (base::SysInfo::IsRunningOnChromeOS()) {
       LOG(ERROR)
           << "User is ephemeral or guest! Fallback to default wallpaper.";
@@ skipping 17 matching lines @@
         ->ResetSetWallpaperImage(user_wallpaper, info);
   } else {
     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(account_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
-      // wallpaper::WALLPAPER_LAYOUT_CENTER.
-      // Original wallpaper should be used in this case.
-      // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
-      if (info.layout == wallpaper::WALLPAPER_LAYOUT_CENTER)
-        sub_dir = wallpaper::kOriginalWallpaperSubDir;
-      base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
-      wallpaper_path = wallpaper_path.Append(info.location);
+        info.type == user_manager::User::POLICY ||
+        info.type == user_manager::User::DEVICE) {
+      base::FilePath wallpaper_path;
+      if (info.type != user_manager::User::DEVICE) {
+        const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
+        // Wallpaper is not resized when layout is
+        // wallpaper::WALLPAPER_LAYOUT_CENTER.
+        // Original wallpaper should be used in this case.
+        // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
+        if (info.layout == wallpaper::WALLPAPER_LAYOUT_CENTER)
+          sub_dir = wallpaper::kOriginalWallpaperSubDir;
+        wallpaper_path = GetCustomWallpaperDir(sub_dir);
+        wallpaper_path = wallpaper_path.Append(info.location);
+      } else {
+        wallpaper_path = GetDeviceWallpaperFilePath();
+      }
+
       CustomWallpaperMap::iterator it = wallpaper_cache_.find(account_id);
       // Do not try to load the wallpaper if the path is the same. Since loading
       // could still be in progress, we ignore the existence of the image.
       if (it != wallpaper_cache_.end() && it->second.first == wallpaper_path)
         return;
 
       // Set the new path and reset the existing image - the image will be
       // added once it becomes available.
       wallpaper_cache_[account_id] =
           CustomWallpaperElement(wallpaper_path, gfx::ImageSkia());
@@ skipping 127 matching lines @@
 
   if (!wallpaper_files_id.is_valid())
     LOG(FATAL) << "Wallpaper flies id if invalid!";
 
   SetCustomWallpaper(account_id, wallpaper_files_id, "policy-controlled.jpeg",
                      wallpaper::WALLPAPER_LAYOUT_CENTER_CROPPED,
                      user_manager::User::POLICY, user_image->image(),
                      true /* update wallpaper */);
 }
 
+void WallpaperManager::OnDeviceWallpaperPolicyChanged() {
+  SetDeviceWallpaperIfApplicable(
+      user_manager::UserManager::Get()->IsUserLoggedIn()
+          ? user_manager::UserManager::Get()->GetActiveUser()->GetAccountId()
+          : user_manager::SignInAccountId());
+}
+
+void WallpaperManager::OnDeviceWallpaperExists(const AccountId& account_id,
+                                               const std::string& url,
+                                               const std::string& hash,
+                                               bool exist) {
+  if (exist) {
+    base::PostTaskAndReplyWithResult(
+        BrowserThread::GetBlockingPool(), FROM_HERE,
+        base::Bind(&CheckDeviceWallpaperMatchHash, GetDeviceWallpaperFilePath(),
+                   hash),
+        base::Bind(&WallpaperManager::OnCheckDeviceWallpaperMatchHash,
+                   weak_factory_.GetWeakPtr(), account_id, url, hash));
+  } else {
+    GURL device_wallpaper_url(url);
+    device_wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
+        g_browser_process->system_request_context(), device_wallpaper_url,
+        GetDeviceWallpaperDir(), GetDeviceWallpaperFilePath(),
+        base::Bind(&WallpaperManager::OnDeviceWallpaperDownloaded,
+                   weak_factory_.GetWeakPtr(), account_id, hash)));
+    device_wallpaper_downloader_->Start();
+  }
+}
+
+void WallpaperManager::OnDeviceWallpaperDownloaded(const AccountId& account_id,
+                                                   const std::string& hash,
+                                                   bool success,
+                                                   const GURL& url) {
+  if (!success) {
+    LOG(ERROR) << "Failed to download the device wallpaper. Fallback to "
+                  "default wallpaper.";
+    SetDefaultWallpaperDelayed(account_id);
+    return;
+  }
+
+  base::PostTaskAndReplyWithResult(
+      BrowserThread::GetBlockingPool(), FROM_HERE,
+      base::Bind(&CheckDeviceWallpaperMatchHash, GetDeviceWallpaperFilePath(),
+                 hash),
+      base::Bind(&WallpaperManager::OnCheckDeviceWallpaperMatchHash,
+                 weak_factory_.GetWeakPtr(), account_id, url.spec(), hash));
+}
+
+void WallpaperManager::OnCheckDeviceWallpaperMatchHash(
+    const AccountId& account_id,
+    const std::string& url,
+    const std::string& hash,
+    bool match) {
+  if (!match) {
+    if (retry_download_if_failed_) {
+      // We only retry to download the device wallpaper one more time if the
+      // hash doesn't match.
+      retry_download_if_failed_ = false;
+      GURL device_wallpaper_url(url);
+      device_wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
+          g_browser_process->system_request_context(), device_wallpaper_url,
+          GetDeviceWallpaperDir(), GetDeviceWallpaperFilePath(),
+          base::Bind(&WallpaperManager::OnDeviceWallpaperDownloaded,
+                     weak_factory_.GetWeakPtr(), account_id, hash)));
+      device_wallpaper_downloader_->Start();
+    } else {
+      LOG(ERROR) << "The device wallpaper hash doesn't match with provided "
+                    "hash value. Fallback to default wallpaper! ";
+      SetDefaultWallpaperDelayed(account_id);
+
+      // Reset the boolean variable so that it can retry to download when the
+      // next device wallpaper request comes in.
+      retry_download_if_failed_ = true;
+    }
+    return;
+  }
+
+  user_image_loader::StartWithFilePath(
+      task_runner_, GetDeviceWallpaperFilePath(),
+      ImageDecoder::ROBUST_JPEG_CODEC,
+      0,  // Do not crop.
+      base::Bind(&WallpaperManager::OnDeviceWallpaperDecoded,
+                 weak_factory_.GetWeakPtr(), account_id));
+}
+
+void WallpaperManager::OnDeviceWallpaperDecoded(
+    const AccountId& account_id,
+    std::unique_ptr<user_manager::UserImage> user_image) {
+  WallpaperInfo wallpaper_info = {GetDeviceWallpaperFilePath().value(),
+                                  wallpaper::WALLPAPER_LAYOUT_CENTER_CROPPED,
+                                  user_manager::User::DEVICE,
+                                  base::Time::Now().LocalMidnight()};
+  if (user_manager::UserManager::Get()->IsUserLoggedIn()) {
+    // In a user's session treat the device wallpaper as a normal custom
+    // wallpaper. It should be persistent and can be overriden by other user
+    // selected wallpapers.
+    SetUserWallpaperInfo(account_id, wallpaper_info, true /* is_persistent */);
+    GetPendingWallpaper(account_id, false)
+        ->ResetSetWallpaperImage(user_image->image(), wallpaper_info);
+    wallpaper_cache_[account_id] = CustomWallpaperElement(
+        GetDeviceWallpaperFilePath(), user_image->image());
+  } else {
+    // In the login screen set the device wallpaper as the wallpaper.
+    GetPendingWallpaper(user_manager::SignInAccountId(), false)
+        ->ResetSetWallpaperImage(user_image->image(), wallpaper_info);
+  }
+}
+
 void WallpaperManager::InitializeRegisteredDeviceWallpaper() {
   if (user_manager::UserManager::Get()->IsUserLoggedIn())
     return;
 
   bool disable_boot_animation =
       GetCommandLine()->HasSwitch(switches::kDisableBootAnimation);
   bool show_users = true;
   bool result = CrosSettings::Get()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn, &show_users);
   DCHECK(result) << "Unable to fetch setting "
                  << kAccountsPrefShowUserNamesOnSignIn;
   const user_manager::UserList& users =
       user_manager::UserManager::Get()->GetUsers();
   int public_session_user_index = FindPublicSession(users);
   if ((!show_users && public_session_user_index == -1) || users.empty()) {
     // Boot into sign in form, preload default wallpaper.
-    SetDefaultWallpaperDelayed(user_manager::SignInAccountId());
+    if (!SetDeviceWallpaperIfApplicable(user_manager::SignInAccountId()))
+      SetDefaultWallpaperDelayed(user_manager::SignInAccountId());
     return;
   }
 
   if (!disable_boot_animation) {
     int index = public_session_user_index != -1 ? public_session_user_index : 0;
     // Normal boot, load user wallpaper.
     // If normal boot animation is disabled wallpaper would be set
     // asynchronously once user pods are loaded.
     SetUserWallpaperDelayed(users[index]->GetAccountId());
   }
@@ skipping 38 matching lines @@
   if (!base::StringToInt64(date_string, &date_val))
     return false;
 
   info->location = location;
   info->layout = static_cast<wallpaper::WallpaperLayout>(layout);
   info->type = static_cast<user_manager::User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
+bool WallpaperManager::ShouldSetDeviceWallpaper(const AccountId& account_id,
+                                                std::string* url,
+                                                std::string* hash) {
+  // Only allow the device wallpaper for enterprise managed devices.
+  if (!g_browser_process->platform_part()
+           ->browser_policy_connector_chromeos()
+           ->IsEnterpriseManaged()) {
+    return false;
+  }
+
+  const base::DictionaryValue* dict = nullptr;
+  if (!CrosSettings::Get()->GetDictionary(kDeviceWallpaperImage, &dict) ||
+      !dict->GetStringWithoutPathExpansion("url", url) ||
+      !dict->GetStringWithoutPathExpansion("hash", hash)) {
+    return false;
+  }
+
+  // Only set the device wallpaper if 1) we're at the login screen or 2) there
+  // is no user policy wallpaper in a user session and the user has the default
+  // wallpaper or device wallpaper in a user session. Note in the latter case,
+  // the device wallpaper can be overridden by user-selected wallpapers.
+  if (user_manager::UserManager::Get()->IsUserLoggedIn()) {
+    WallpaperInfo info;
+    if (GetUserWallpaperInfo(account_id, &info) &&
+        (info.type == user_manager::User::POLICY ||
+         (info.type != user_manager::User::DEFAULT &&
+          info.type != user_manager::User::DEVICE))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+base::FilePath WallpaperManager::GetDeviceWallpaperDir() {
+  base::FilePath wallpaper_dir;
+  if (!PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir)) {
+    LOG(ERROR) << "Unable to get wallpaper dir.";
+    return base::FilePath();
+  }
+  return wallpaper_dir.Append(kDeviceWallpaperDir);
+}
+
+base::FilePath WallpaperManager::GetDeviceWallpaperFilePath() {
+  return GetDeviceWallpaperDir().Append(kDeviceWallpaperFile);
+}
+
 void WallpaperManager::OnWallpaperDecoded(
     const AccountId& account_id,
     wallpaper::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     std::unique_ptr<user_manager::UserImage> user_image) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
@@ skipping 85 matching lines @@
   SetDefaultWallpaperPath(
       rescaled_files->path_rescaled_small(), std::move(small_wallpaper_image),
       rescaled_files->path_rescaled_large(), std::move(large_wallpaper_image));
   VLOG(1) << "Customized default wallpaper applied.";
 }
 
 size_t WallpaperManager::GetPendingListSizeForTesting() const {
   return loading_.size();
 }
 
+wallpaper::WallpaperFilesId WallpaperManager::GetFilesId(
+    const AccountId& account_id) const {
+  std::string stored_value;
+  if (user_manager::known_user::GetStringPref(account_id, kWallpaperFilesId,
+                                              &stored_value)) {
+    return wallpaper::WallpaperFilesId::FromString(stored_value);
+  }
+  const std::string& old_id = account_id.GetUserEmail();  // Migrated
+  const wallpaper::WallpaperFilesId files_id = HashWallpaperFilesIdStr(old_id);
+  SetKnownUserWallpaperFilesId(account_id, files_id);
+  return files_id;
+}
+
+bool WallpaperManager::SetDeviceWallpaperIfApplicable(
+    const AccountId& account_id) {
+  std::string url;
+  std::string hash;
+  if (ShouldSetDeviceWallpaper(account_id, &url, &hash)) {
+    // Check if the device wallpaper exists and matches the hash. If so, use it
+    // directly. Otherwise download it first.
+    base::PostTaskAndReplyWithResult(
+        BrowserThread::GetBlockingPool(), FROM_HERE,
+        base::Bind(&base::PathExists, GetDeviceWallpaperFilePath()),
+        base::Bind(&WallpaperManager::OnDeviceWallpaperExists,
+                   weak_factory_.GetWeakPtr(), account_id, url, hash));
+    return true;
+  }
+  return false;
+}
+
 void WallpaperManager::UserChangedChildStatus(user_manager::User* user) {
   SetUserWallpaperNow(user->GetAccountId());
 }
 
 void WallpaperManager::SetDefaultWallpaperPathsFromCommandLine(
     base::CommandLine* command_line) {
   default_small_wallpaper_file_ = command_line->GetSwitchValuePath(
       chromeos::switches::kDefaultWallpaperSmall);
   default_large_wallpaper_file_ = command_line->GetSwitchValuePath(
       chromeos::switches::kDefaultWallpaperLarge);
@@ skipping 66 matching lines @@
       default_wallpaper_image_.reset(
           new user_manager::UserImage(*large_wallpaper_image));
       default_wallpaper_image_->set_file_path(default_large_wallpaper_file);
     }
   }
 
   if (need_update_screen)
     DoSetDefaultWallpaper(EmptyAccountId(), MovableOnDestroyCallbackHolder());
 }
 
-wallpaper::WallpaperFilesId WallpaperManager::GetFilesId(
-    const AccountId& account_id) const {
-  std::string stored_value;
-  if (user_manager::known_user::GetStringPref(account_id, kWallpaperFilesId,
-                                              &stored_value)) {
-    return wallpaper::WallpaperFilesId::FromString(stored_value);
-  }
-  const std::string& old_id = account_id.GetUserEmail();  // Migrated
-  const wallpaper::WallpaperFilesId files_id = HashWallpaperFilesIdStr(old_id);
-  SetKnownUserWallpaperFilesId(account_id, files_id);
-  return files_id;
-}
-
 }  // namespace chromeos