Install and launch kiosk app from cached crx file at start up.

chrome/browser/chromeos/extensions/external_cache.cc

 // Copyright (c) 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/extensions/external_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 40 matching lines @@
 ExternalCache::~ExternalCache() {
 }
 
 void ExternalCache::Shutdown(const base::Closure& callback) {
   local_cache_.Shutdown(callback);
 }
 
 void ExternalCache::UpdateExtensionsList(
     scoped_ptr<base::DictionaryValue> prefs) {
   extensions_ = prefs.Pass();
+  extensions_status_.clear();
 
   if (extensions_->empty()) {
     // If list of know extensions is empty, don't init cache on disk. It is
     // important shortcut for test to don't wait forever for cache dir
     // initialization that should happen outside of Chrome on real device.
     cached_extensions_->Clear();
     UpdateExtensionLoader();
     return;
   }
 
@@ skipping 73 matching lines @@
 
 void ExternalCache::OnExtensionDownloadFailed(
     const std::string& id,
     extensions::ExtensionDownloaderDelegate::Error error,
     const extensions::ExtensionDownloaderDelegate::PingResult& ping_result,
     const std::set<int>& request_ids) {
   if (error == NO_UPDATE_AVAILABLE) {
     if (!cached_extensions_->HasKey(id)) {
       LOG(ERROR) << "ExternalCache extension " << id
                  << " not found on update server";
+      extensions_status_[id] = DOWNLOAD_FAILED;
       delegate_->OnExtensionDownloadFailed(id, error);
     } else {
+      // No version update for an already cached extension.
+      extensions_status_[id] = DOWNLOAD_SUCCEEDED;
       delegate_->OnExtensionLoadedInCache(id);
     }
   } else {
     LOG(ERROR) << "ExternalCache failed to download extension " << id
                << ", error " << error;
+    extensions_status_[id] = DOWNLOAD_FAILED;
     delegate_->OnExtensionDownloadFailed(id, error);
   }
 }
 
 void ExternalCache::OnExtensionDownloadFinished(
     const std::string& id,
     const base::FilePath& path,
     bool file_ownership_passed,
     const GURL& download_url,
     const std::string& version,
     const extensions::ExtensionDownloaderDelegate::PingResult& ping_result,
     const std::set<int>& request_ids) {
   DCHECK(file_ownership_passed);
   local_cache_.PutExtension(id, path, version,
                             base::Bind(&ExternalCache::OnPutExtension,
                                        weak_ptr_factory_.GetWeakPtr(),
                                        id));
 }
 
 bool ExternalCache::IsExtensionPending(const std::string& id) {
   // Pending means that there is no installed version yet.
-  return extensions_->HasKey(id) && !cached_extensions_->HasKey(id);
+  return extensions_->HasKey(id) && !cached_extensions_->HasKey(id) &&
+         extensions_status_.find(id) != extensions_status_.end() &&
+         extensions_status_[id] != DOWNLOAD_FAILED;

[xiyuan, 2014/05/29 19:49:01]

Not sure if we should change this. Other call sites might use the function as a
signal of whether to use the cached extension. The code here changes that
expectation.

[jennyz, 2014/07/07 21:11:12]

removed the change from this function.

+}
+
+bool ExternalCache::IsExtensionPendingForUpdateCheck(const std::string& id) {
+  return extensions_->HasKey(id) && cached_extensions_->HasKey(id) &&
+         extensions_status_.find(id) != extensions_status_.end() &&
+         extensions_status_[id] == DOWNLOAD_PENDING;
 }
 
 bool ExternalCache::GetExtensionExistingVersion(const std::string& id,
                                                 std::string* version) {
   base::DictionaryValue* extension_dictionary = NULL;
   if (cached_extensions_->GetDictionary(id, &extension_dictionary)) {
     if (extension_dictionary->GetString(
             extensions::ExternalProviderImpl::kExternalVersion, version)) {
       return true;
     }
@@ skipping 13 matching lines @@
   if (local_cache_.is_shutdown())
     return;
 
   // If request_context_ is missing we can't download anything.
   if (!downloader_ && request_context_) {
     downloader_.reset(
         new extensions::ExtensionDownloader(this, request_context_));
   }
 
   cached_extensions_->Clear();
+  extensions_status_.clear();
   for (base::DictionaryValue::Iterator it(*extensions_.get());
        !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* entry = NULL;
     if (!it.value().GetAsDictionary(&entry)) {
       LOG(ERROR) << "ExternalCache found bad entry with type "
                  << it.value().GetType();
       continue;
     }
 
     bool keep_if_present =
         entry->HasKey(extensions::ExternalProviderImpl::kKeepIfPresent);
     std::string external_update_url;
     entry->GetString(extensions::ExternalProviderImpl::kExternalUpdateUrl,
                      &external_update_url);
     if (downloader_ && !keep_if_present) {
       GURL update_url;
       if (!external_update_url.empty())
         update_url = GURL(external_update_url);
       else if (always_check_updates_)
         update_url = extension_urls::GetWebstoreUpdateUrl();
 
-      if (update_url.is_valid())
+      if (update_url.is_valid()) {
         downloader_->AddPendingExtension(it.key(), update_url, 0);
+        extensions_status_[it.key()] = DOWNLOAD_PENDING;
+      }
     }
 
     base::FilePath file_path;
     std::string version;
     if (local_cache_.GetExtension(it.key(), &file_path, &version)) {
       // Copy entry to don't modify it inside extensions_.
       base::DictionaryValue* entry_copy = entry->DeepCopy();
 
       if (extension_urls::IsWebstoreUpdateUrl(GURL(external_update_url))) {
         entry_copy->SetBoolean(
@@ skipping 59 matching lines @@
                        &update_url) &&
       extension_urls::IsWebstoreUpdateUrl(GURL(update_url))) {
     entry->SetBoolean(extensions::ExternalProviderImpl::kIsFromWebstore, true);
   }
   entry->Remove(extensions::ExternalProviderImpl::kExternalUpdateUrl, NULL);
   entry->SetString(extensions::ExternalProviderImpl::kExternalVersion, version);
   entry->SetString(extensions::ExternalProviderImpl::kExternalCrx,
                    file_path.value());
 
   cached_extensions_->Set(id, entry);
+  extensions_status_[id] = DOWNLOAD_SUCCEEDED;
   if (delegate_)
     delegate_->OnExtensionLoadedInCache(id);
   UpdateExtensionLoader();
 }
 
 std::string ExternalCache::Delegate::GetInstalledExtensionVersion(
     const std::string& id) {
   return std::string();
 }
 
 }  // namespace chromeos