Automatically retry the following URLFetchers when the network changes:

chrome/browser/policy/app_pack_updater.cc

 // Copyright (c) 2012 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/policy/app_pack_updater.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 84 matching lines @@
                                        weak_ptr_factory_.GetWeakPtr()));
   } else {
     // Linger until the device switches to DEVICE_MODE_KIOSK and the app pack
     // device setting appears.
   }
 }
 
 AppPackUpdater::~AppPackUpdater() {
   chromeos::CrosSettings::Get()->RemoveSettingsObserver(
       chromeos::kAppPack, this);
-  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 extensions::ExternalLoader* AppPackUpdater::CreateExternalLoader() {
   if (created_extension_loader_) {
     NOTREACHED();
     return NULL;
   }
   created_extension_loader_ = true;
   AppPackExternalLoader* loader = new AppPackExternalLoader();
   extension_loader_ = loader->AsWeakPtr();
@@ skipping 18 matching lines @@
 void AppPackUpdater::Init() {
   if (initialized_)
     return;
 
   initialized_ = true;
   worker_pool_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
       content::NotificationService::AllBrowserContextsAndSources());
-  net::NetworkChangeNotifier::AddIPAddressObserver(this);
   LoadPolicy();
 }
 
 void AppPackUpdater::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_SYSTEM_SETTING_CHANGED:
       DCHECK_EQ(chromeos::kAppPack,
                 *content::Details<const std::string>(details).ptr());
@@ skipping 10 matching lines @@
           content::Source<extensions::CrxInstaller>(source).ptr();
       OnDamagedFileDetected(installer->source_file());
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
-void AppPackUpdater::OnIPAddressChanged() {
-  // Check if the AppPack has been fully downloaded whenever the network
-  // changes. This allows the AppPack to recover in case the network wasn't
-  // ready early during startup.
-  // To avoid performing too many update checks in case the network conditions
-  // change too often, an update is only triggered now if there are extensions
-  // configured via policy that haven't been checked for updates yet.
-  for (PolicyEntryMap::iterator it = app_pack_extensions_.begin();
-       it != app_pack_extensions_.end(); ++it) {
-    if (!it->second.update_checked) {
-      // |id| is configured via policy, but hasn't been updated before.
-      // Drop any pending requests and start a full check now.
-      VLOG(1) << "Extension " << it->first << " hasn't been checked yet, "
-              << "new update triggered now by network change notification.";
-      downloader_.reset();
-      weak_ptr_factory_.InvalidateWeakPtrs();
-      LoadPolicy();
-      break;
-    }
-  }
-}
-
 void AppPackUpdater::LoadPolicy() {
   chromeos::CrosSettings* settings = chromeos::CrosSettings::Get();
   if (chromeos::CrosSettingsProvider::TRUSTED != settings->PrepareTrustedValues(
           base::Bind(&AppPackUpdater::LoadPolicy,
                      weak_ptr_factory_.GetWeakPtr()))) {
     return;
   }
 
   app_pack_extensions_.clear();
   const base::Value* value = settings->GetPref(chromeos::kAppPack);
   const base::ListValue* list = NULL;
   if (value && value->GetAsList(&list)) {
     for (base::ListValue::const_iterator it = list->begin();
          it != list->end(); ++it) {
       base::DictionaryValue* dict = NULL;
       if (!(*it)->GetAsDictionary(&dict)) {
         LOG(WARNING) << "AppPack entry is not a dictionary, ignoring.";
         continue;
       }
       std::string id;
       std::string update_url;
       if (dict->GetString(kExtensionId, &id) &&
           dict->GetString(kUpdateUrl, &update_url)) {
-        app_pack_extensions_[id].update_url = update_url;
-        app_pack_extensions_[id].update_checked = false;
+        app_pack_extensions_[id] = update_url;
       } else {
         LOG(WARNING) << "Failed to read required fields for an AppPack entry, "
                      << "ignoring.";
       }
     }
   }
 
   VLOG(1) << "Refreshed AppPack policy, got " << app_pack_extensions_.size()
           << " entries.";
 
@@ skipping 166 matching lines @@
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetString(extensions::ExternalProviderImpl::kExternalCrx,
                     it->second.path);
     dict->SetString(extensions::ExternalProviderImpl::kExternalVersion,
                     it->second.cached_version);
 
     // Include this optional flag if the extension's update url is the Webstore.
     PolicyEntryMap::iterator policy_entry = app_pack_extensions_.find(id);
     if (policy_entry != app_pack_extensions_.end() &&
         extension_urls::IsWebstoreUpdateUrl(
-            GURL(policy_entry->second.update_url))) {
+            GURL(policy_entry->second))) {
       dict->SetBoolean(extensions::ExternalProviderImpl::kIsFromWebstore, true);
     }
 
     prefs->Set(it->first, dict);
 
     VLOG(1) << "Updating AppPack extension loader, added " << it->second.path;
   }
 
   extension_loader_->SetCurrentAppPackExtensions(prefs.Pass());
 }
 
 void AppPackUpdater::DownloadMissingExtensions() {
   // Check for updates for all extensions configured by the policy. Some of
   // them may already be in the cache; only those with updated version will be
   // downloaded, in that case.
   if (!downloader_.get()) {
     downloader_.reset(new extensions::ExtensionDownloader(this,
                                                           request_context_));
   }
   for (PolicyEntryMap::iterator it = app_pack_extensions_.begin();
        it != app_pack_extensions_.end(); ++it) {
-    downloader_->AddPendingExtension(it->first, GURL(it->second.update_url), 0);
+    downloader_->AddPendingExtension(it->first, GURL(it->second), 0);
   }
   VLOG(1) << "Downloading AppPack update manifest now";
   downloader_->StartAllPending();
 }
 
 void AppPackUpdater::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 (!ContainsKey(cached_extensions_, id))
       LOG(ERROR) << "AppPack extension " << id << " not found on update server";
-    SetUpdateChecked(id);
   } else {
     LOG(ERROR) << "AppPack failed to download extension " << id
                << ", error " << error;
   }
 }
 
 void AppPackUpdater::OnExtensionDownloadFinished(
     const std::string& id,
     const FilePath& path,
     const GURL& download_url,
     const std::string& version,
     const extensions::ExtensionDownloaderDelegate::PingResult& ping_result,
     const std::set<int>& request_ids) {
-  // Just downloaded the latest version, no need to do further update checks
-  // for this extension.
-  SetUpdateChecked(id);
-
   // The explicit copy ctors are to make sure that Bind() binds a copy and not
   // a reference to the arguments.
   PostBlockingTask(FROM_HERE,
                    base::Bind(&AppPackUpdater::BlockingInstallCacheEntry,
                               weak_ptr_factory_.GetWeakPtr(),
                               std::string(id),
                               FilePath(path),
                               std::string(version)));
 }
 
@@ skipping 120 matching lines @@
 
 void AppPackUpdater::SetScreenSaverPath(const FilePath& path) {
   // Don't invoke the callback if the path isn't changing.
   if (path != screen_saver_path_) {
     screen_saver_path_ = path;
     if (!screen_saver_update_callback_.is_null())
       screen_saver_update_callback_.Run(screen_saver_path_);
   }
 }
 
-void AppPackUpdater::SetUpdateChecked(const std::string& id) {
-  PolicyEntryMap::iterator entry = app_pack_extensions_.find(id);
-  if (entry != app_pack_extensions_.end())
-    entry->second.update_checked = true;
-}
-
 }  // namespace policy