Translate device-local account IDs to user IDs

chrome/browser/chromeos/app_mode/kiosk_app_data.cc

 // Copyright 2013 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/app_mode/kiosk_app_data.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 228 matching lines @@
 
   base::WeakPtr<KioskAppData> client_;
 
   DISALLOW_COPY_AND_ASSIGN(WebstoreDataParser);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // KioskAppData
 
 KioskAppData::KioskAppData(KioskAppDataDelegate* delegate,
-                           const std::string& app_id)
+                           const std::string& app_id,
+                           const std::string& user_id)
     : delegate_(delegate),
       status_(STATUS_INIT),
-      id_(app_id) {
+      app_id_(app_id),
+      user_id_(user_id) {
 }
 
 KioskAppData::~KioskAppData() {}
 
 void KioskAppData::Load() {
   SetStatus(STATUS_LOADING);
 
   if (LoadFromCache())
     return;
 
   StartFetch();
 }
 
 void KioskAppData::ClearCache() {
   PrefService* local_state = g_browser_process->local_state();
 
   DictionaryPrefUpdate dict_update(local_state,
                                    KioskAppManager::kKioskDictionaryName);
 
-  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + id_;
+  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + app_id_;
   dict_update->Remove(app_key, NULL);
 
   if (!icon_path_.empty()) {
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&file_util::Delete), icon_path_, false));
   }
 }
 
 bool KioskAppData::IsLoading() const {
   return status_ == STATUS_LOADING;
 }
 
 void KioskAppData::SetStatus(Status status) {
   if (status_ == status)
     return;
 
   status_ = status;
 
   if (!delegate_)
     return;
 
   switch (status_) {
     case STATUS_INIT:
       break;
     case STATUS_LOADING:
     case STATUS_LOADED:
-      delegate_->OnKioskAppDataChanged(id_);
+      delegate_->OnKioskAppDataChanged(app_id_);
       break;
     case STATUS_ERROR:
-      delegate_->OnKioskAppDataLoadFailure(id_);
+      delegate_->OnKioskAppDataLoadFailure(app_id_);
       break;
   };
 }
 
 net::URLRequestContextGetter* KioskAppData::GetRequestContextGetter() {
   return g_browser_process->system_request_context();
 }
 
 bool KioskAppData::LoadFromCache() {
-  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + id_;
+  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + app_id_;
   std::string name_key = app_key + '.' + kKeyName;
   std::string icon_path_key = app_key + '.' + kKeyIcon;
 
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dict =
       local_state->GetDictionary(KioskAppManager::kKioskDictionaryName);
 
   icon_path_.clear();
   std::string icon_path_string;
   if (!dict->GetString(name_key, &name_) ||
       !dict->GetString(icon_path_key, &icon_path_string)) {
     return false;
   }
   icon_path_ = base::FilePath(icon_path_string);
 
   // IconLoader deletes itself when done.
   (new IconLoader(AsWeakPtr(), icon_path_))->Start();
   return true;
 }
 
 void KioskAppData::SetCache(const std::string& name,
                             const base::FilePath& icon_path) {
-  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + id_;
+  std::string app_key = std::string(KioskAppManager::kKeyApps) + '.' + app_id_;
   std::string name_key = app_key + '.' + kKeyName;
   std::string icon_path_key = app_key + '.' + kKeyIcon;
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(local_state,
                                    KioskAppManager::kKioskDictionaryName);
   dict_update->SetString(name_key, name);
   dict_update->SetString(icon_path_key, icon_path.value());
   icon_path_ = icon_path;
 }
@@ skipping 19 matching lines @@
   std::vector<unsigned char> image_data;
   CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(icon, false, &image_data));
   raw_icon_ = new base::RefCountedString;
   raw_icon_->data().assign(image_data.begin(), image_data.end());
 
   base::FilePath cache_dir;
   if (delegate_)
     delegate_->GetKioskAppIconCacheDir(&cache_dir);
 
   base::FilePath icon_path =
-      cache_dir.AppendASCII(id_).AddExtension(kIconFileExtension);
+      cache_dir.AppendASCII(app_id_).AddExtension(kIconFileExtension);
   BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE,
       base::Bind(&SaveIconToLocalOnBlockingPool, icon_path, raw_icon_));
 
   SetCache(name_, icon_path);
   SetStatus(STATUS_LOADED);
 }
 
 void KioskAppData::OnWebstoreParseFailure() {
   SetStatus(STATUS_ERROR);
 }
 
 void KioskAppData::StartFetch() {
   webstore_fetcher_.reset(new extensions::WebstoreDataFetcher(
       this,
       GetRequestContextGetter(),
       GURL(),
-      id_));
+      app_id_));
   webstore_fetcher_->Start();
 }
 
 void KioskAppData::OnWebstoreRequestFailure() {
   SetStatus(STATUS_ERROR);
 }
 
 void KioskAppData::OnWebstoreResponseParseSuccess(
       base::DictionaryValue* webstore_data) {
   // Takes ownership of |webstore_data|.
@@ skipping 18 matching lines @@
     return;
   }
   GURL icon_url = GURL(extension_urls::GetWebstoreLaunchURL()).Resolve(
       icon_url_string);
   if (!icon_url.is_valid()) {
     OnWebstoreResponseParseFailure(kInvalidWebstoreResponseError);
     return;
   }
 
   // WebstoreDataParser deletes itself when done.
-  (new WebstoreDataParser(AsWeakPtr()))->Start(id_,
+  (new WebstoreDataParser(AsWeakPtr()))->Start(app_id_,
                                                manifest,
                                                icon_url,
                                                GetRequestContextGetter());
 }
 
 void KioskAppData::OnWebstoreResponseParseFailure(const std::string& error) {
   webstore_fetcher_.reset();
   SetStatus(STATUS_ERROR);
 }
 
 }  // namespace chromeos