kiosk: Do update check during launch.

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"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_data_delegate.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/image_loader.h"
 #include "chrome/browser/extensions/webstore_data_fetcher.h"
 #include "chrome/browser/extensions/webstore_install_helper.h"
 #include "chrome/browser/image_decoder.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/manifest_handlers/icons_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 // Keys for local state data. See sample layout in KioskAppManager.
 const char kKeyName[] = "name";
 const char kKeyIcon[] = "icon";
@@ skipping 243 matching lines @@
   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(&base::DeleteFile), icon_path_, false));
   }
 }
 
+void KioskAppData::LoadFromInstalledApp(Profile* profile,
+                                        const extensions::Extension* app) {
+  SetStatus(STATUS_LOADING);
+
+  if (!app) {
+    app = extensions::ExtensionSystem::Get(profile)
+              ->extension_service()
+              ->GetInstalledExtension(app_id_);
+  }
+
+  DCHECK_EQ(app_id_, app->id());
+
+  name_ = app->name();
+
+  const int kIconSize = extension_misc::EXTENSION_ICON_LARGE;
+  extensions::ExtensionResource image = extensions::IconsInfo::GetIconResource(
+      app, kIconSize, ExtensionIconSet::MATCH_BIGGER);
+  extensions::ImageLoader::Get(profile)->LoadImageAsync(
+      app, image, gfx::Size(kIconSize, kIconSize),
+      base::Bind(&KioskAppData::OnExtensionIconLoaded, AsWeakPtr()));
+}
+
 bool KioskAppData::IsLoading() const {
   return status_ == STATUS_LOADING;
 }
 
 void KioskAppData::SetStatus(Status status) {
   if (status_ == status)
     return;
 
   status_ = status;
 
@@ skipping 46 matching lines @@
   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;
 }
 
-void KioskAppData::OnIconLoadSuccess(
-    const scoped_refptr<base::RefCountedString>& raw_icon,
-    const gfx::ImageSkia& icon) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  raw_icon_ = raw_icon;
-  icon_ = icon;
-  SetStatus(STATUS_LOADED);
-}
-
-void KioskAppData::OnIconLoadFailure() {
-  // Re-fetch data from web store when failed to load cached data.
-  StartFetch();
-}
-
-void KioskAppData::OnWebstoreParseSuccess(const SkBitmap& icon) {
+void KioskAppData::SetCache(const std::string& name, const SkBitmap& icon) {
   icon_ = gfx::ImageSkia::CreateFrom1xBitmap(icon);
   icon_.MakeThreadSafe();
 
   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(app_id_).AddExtension(kIconFileExtension);
   BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE,
       base::Bind(&SaveIconToLocalOnBlockingPool, icon_path, raw_icon_));
 
-  SetCache(name_, icon_path);
+  SetCache(name, icon_path);
+}
+
+void KioskAppData::OnExtensionIconLoaded(const gfx::Image& icon) {
+  if (icon.IsEmpty()) {
+    LOG(WARNING) << "Failed to load icon from installed app"
+                 << ", id=" << app_id_;
+    SetCache(name_, *extensions::IconsInfo::GetDefaultAppIcon().bitmap());
+  } else {
+    SetCache(name_, icon.AsBitmap());
+  }
+
   SetStatus(STATUS_LOADED);
 }
 
+void KioskAppData::OnIconLoadSuccess(
+    const scoped_refptr<base::RefCountedString>& raw_icon,
+    const gfx::ImageSkia& icon) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  raw_icon_ = raw_icon;
+  icon_ = icon;
+  SetStatus(STATUS_LOADED);
+}
+
+void KioskAppData::OnIconLoadFailure() {
+  // Re-fetch data from web store when failed to load cached data.
+  StartFetch();
+}
+
+void KioskAppData::OnWebstoreParseSuccess(const SkBitmap& icon) {
+  SetCache(name_, icon);
+  SetStatus(STATUS_LOADED);
+}
+
 void KioskAppData::OnWebstoreParseFailure() {
   SetStatus(STATUS_ERROR);
 }
 
 void KioskAppData::StartFetch() {
   webstore_fetcher_.reset(new extensions::WebstoreDataFetcher(
       this,
       GetRequestContextGetter(),
       GURL(),
       app_id_));
@@ skipping 50 matching lines @@
   if (!response->GetString(key, value)) {
     LOG(ERROR) << "Webstore response error (" << key
                << "): " << ValueToString(response);
     OnWebstoreResponseParseFailure(kInvalidWebstoreResponseError);
     return false;
   }
   return true;
 }
 
 }  // namespace chromeos