Adding ExtensionPrefs methods for storing update-when-idle data....

chrome/browser/extensions/extension_updater.cc

 // Copyright (c) 2009 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/extensions/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/logging.h"
@@ skipping 240 matching lines @@
   }
 
   DCHECK(!update_url.is_empty());
   DCHECK(update_url.is_valid());
 
   ManifestFetchData* fetch = NULL;
   std::multimap<GURL, ManifestFetchData*>::iterator existing_iter =
       fetches_.find(update_url);
 
   // Find or create a ManifestFetchData to add this extension to.
-  int ping_days = CalculatePingDays(service_->LastPingDay(id));
+  int ping_days =
+      CalculatePingDays(service_->extension_prefs()->LastPingDay(id));
   while (existing_iter != fetches_.end()) {
     if (existing_iter->second->AddExtension(id, version.GetString(),
                                             ping_days)) {
       fetch = existing_iter->second;
       break;
     }
     existing_iter++;
   }
   if (!fetch) {
     fetch = new ManifestFetchData(update_url);
@@ skipping 21 matching lines @@
     }
     if (file_util::WriteFile(path, data.c_str(), data.length()) !=
         static_cast<int>(data.length())) {
       // TODO(asargent) - It would be nice to back off updating alltogether if
       // the disk is full. (http://crbug.com/12763).
       LOG(ERROR) << "Failed to write temporary file";
       file_util::Delete(path, false);
       return;
     }
 
-    // The ExtensionUpdater is now responsible for cleaning up the temp file
-    // from disk.
+    // The ExtensionUpdater now owns the temp file.
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(
             updater.get(), &ExtensionUpdater::OnCRXFileWritten, extension_id,
             path, download_url));
   }
 
-  void DeleteFile(const FilePath& path) {
-    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
-    if (!file_util::Delete(path, false)) {
-      LOG(WARNING) << "Failed to delete temp file " << path.value();
-    }
-  }
-
  private:
   friend class base::RefCountedThreadSafe<ExtensionUpdaterFileHandler>;
 
   ~ExtensionUpdaterFileHandler() {}
 };
 
 ExtensionUpdater::ExtensionUpdater(ExtensionUpdateService* service,
                                    PrefService* prefs,
                                    int frequency_seconds)
     : service_(service), frequency_seconds_(frequency_seconds),
@@ skipping 218 matching lines @@
       results.daystart_elapsed_seconds >= 0) {
     Time daystart =
       Time::Now() - TimeDelta::FromSeconds(results.daystart_elapsed_seconds);
 
     const std::set<std::string>& extension_ids = fetch_data.extension_ids();
     std::set<std::string>::const_iterator i;
     for (i = extension_ids.begin(); i != extension_ids.end(); i++) {
       bool did_ping = fetch_data.DidPing(*i);
       if (did_ping) {
         if (*i == kBlacklistAppID) {
-          service_->SetBlacklistLastPingDay(daystart);
+          service_->extension_prefs()->SetBlacklistLastPingDay(daystart);
         } else if (service_->GetExtensionById(*i, true) != NULL) {
-          service_->SetLastPingDay(*i, daystart);
+          service_->extension_prefs()->SetLastPingDay(*i, daystart);
         }
       }
     }
   }
 }
 
 void ExtensionUpdater::ProcessBlacklist(const std::string& data) {
   // Verify sha256 hash value.
   char sha256_hash_value[base::SHA256_LENGTH];
   base::SHA256HashString(data, sha256_hash_value, base::SHA256_LENGTH);
@@ skipping 15 matching lines @@
   prefs_->SetString(kExtensionBlacklistUpdateVersion,
     ASCIIToWide(current_extension_fetch_.version));
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionUpdater::OnCRXFetchComplete(const GURL& url,
                                           const URLRequestStatus& status,
                                           int response_code,
                                           const std::string& data) {
   if (status.status() == URLRequestStatus::SUCCESS &&
-             response_code == 200) {
+      response_code == 200) {
     if (current_extension_fetch_.id == kBlacklistAppID) {
       ProcessBlacklist(data);
     } else {
       // Successfully fetched - now write crx to a file so we can have the
       // ExtensionsService install it.
       ChromeThread::PostTask(
           ChromeThread::FILE, FROM_HERE,
           NewRunnableMethod(
               file_handler_.get(), &ExtensionUpdaterFileHandler::WriteTempFile,
               current_extension_fetch_.id, data, url,
@@ skipping 13 matching lines @@
   if (extensions_pending_.size() > 0) {
     ExtensionFetch next = extensions_pending_.front();
     extensions_pending_.pop_front();
     FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version);
   }
 }
 
 void ExtensionUpdater::OnCRXFileWritten(const std::string& id,
                                         const FilePath& path,
                                         const GURL& download_url) {
+  // The ExtensionsService is now responsible for cleaning up the temp file
+  // at |path|.
   service_->UpdateExtension(id, path, download_url);
 }
 
-void ExtensionUpdater::OnExtensionInstallFinished(const FilePath& path,
-                                                  Extension* extension) {
-  // Have the file_handler_ delete the temp file on the file I/O thread.
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableMethod(
-          file_handler_.get(), &ExtensionUpdaterFileHandler::DeleteFile, path));
-}
 
 void ExtensionUpdater::ScheduleNextCheck(const TimeDelta& target_delay) {
   DCHECK(!timer_.IsRunning());
   DCHECK(target_delay >= TimeDelta::FromSeconds(1));
 
   // Add +/- 10% random jitter.
   double delay_ms = target_delay.InMillisecondsF();
   double jitter_factor = (RandDouble() * .2) - 0.1;
   delay_ms += delay_ms * jitter_factor;
   TimeDelta actual_delay = TimeDelta::FromMilliseconds(
@@ skipping 49 matching lines @@
 
   fetches_builder.ReportStats();
 
   std::vector<ManifestFetchData*> fetches(fetches_builder.GetFetches());
 
   // Start a fetch of the blacklist if needed.
   if (blacklist_checks_enabled_ && service_->HasInstalledExtensions()) {
     ManifestFetchData* blacklist_fetch =
         new ManifestFetchData(GURL(kBlacklistUpdateUrl));
     std::wstring version = prefs_->GetString(kExtensionBlacklistUpdateVersion);
-    int ping_days = CalculatePingDays(service_->BlacklistLastPingDay());
+    int ping_days =
+        CalculatePingDays(service_->extension_prefs()->BlacklistLastPingDay());
     blacklist_fetch->AddExtension(kBlacklistAppID, WideToASCII(version),
                                   ping_days);
     StartUpdateCheck(blacklist_fetch);
   }
 
   // Now start fetching regular extension updates
   for (std::vector<ManifestFetchData*>::const_iterator it = fetches.begin();
        it != fetches.end(); ++it) {
     // StartUpdateCheck makes sure the url isn't already downloading or
     // scheduled, so we don't need to check before calling it. Ownership of
@@ skipping 135 matching lines @@
     extension_fetcher_.reset(
         URLFetcher::Create(kExtensionFetcherId, url, URLFetcher::GET, this));
     extension_fetcher_->set_request_context(
         Profile::GetDefaultRequestContext());
     extension_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                                        net::LOAD_DO_NOT_SAVE_COOKIES);
     extension_fetcher_->Start();
     current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
   }
 }