Delete the omahaproxy-backed extension blacklist and clear its entries from the

chrome/browser/extensions/updater/extension_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/extensions/updater/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/module/module.h"
-#include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "crypto/sha2.h"
 #include "extensions/common/manifest.h"
 
 using base::RandDouble;
 using base::RandInt;
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
-using prefs::kExtensionBlacklistUpdateVersion;
 using prefs::kLastExtensionsUpdateCheck;
 using prefs::kNextExtensionsUpdateCheck;
 
 typedef extensions::ExtensionDownloaderDelegate::Error Error;
 typedef extensions::ExtensionDownloaderDelegate::PingResult PingResult;
 
 namespace {
 
 // Wait at least 5 minutes after browser startup before we do any checks. If you
 // change this value, make sure to update comments where it is used.
@@ skipping 33 matching lines @@
   if (last_active_ping_day.is_null())
     return extensions::ManifestFetchData::kNeverPinged;
   return SanitizeDays((Time::Now() - last_active_ping_day).InDays());
 }
 
 }  // namespace
 
 namespace extensions {
 
 ExtensionUpdater::CheckParams::CheckParams()
-    : check_blacklist(true), install_immediately(false) {}
+    : install_immediately(false) {}
 
 ExtensionUpdater::CheckParams::~CheckParams() {}
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile(
     const std::string& i,
     const base::FilePath& p,
     const GURL& u,
     const std::set<int>& request_ids)
     : extension_id(i),
       path(p),
@@ skipping 17 matching lines @@
 
   bool in_progress;
   int throttle_delay;
   Time check_start;
 };
 
 ExtensionUpdater::ExtensionUpdater(ExtensionServiceInterface* service,
                                    ExtensionPrefs* extension_prefs,
                                    PrefService* prefs,
                                    Profile* profile,
-                                   Blacklist* blacklist,
                                    int frequency_seconds)
     : alive_(false),
       weak_ptr_factory_(this),
       service_(service), frequency_seconds_(frequency_seconds),
       will_check_soon_(false), extension_prefs_(extension_prefs),
-      prefs_(prefs), profile_(profile), blacklist_(blacklist),
+      prefs_(prefs), profile_(profile),
       next_request_id_(0),
       crx_install_is_running_(false) {
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 #ifdef NDEBUG
   // In Release mode we enforce that update checks don't happen too often.
   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 #endif
   frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
 
@@ skipping 216 matching lines @@
   } else {
     for (std::list<std::string>::const_iterator it = params.ids.begin();
          it != params.ids.end(); ++it) {
       const Extension* extension = service_->GetExtensionById(*it, true);
       DCHECK(extension);
       if (downloader_->AddExtension(*extension, request_id))
         request.in_progress_ids_.push_back(extension->id());
     }
   }
 
-  // Start a fetch of the blacklist if needed.
-  if (params.check_blacklist) {
-    ManifestFetchData::PingData ping_data;
-    ping_data.rollcall_days =
-        CalculatePingDays(extension_prefs_->BlacklistLastPingDay());
-    request.in_progress_ids_.push_back(ExtensionDownloader::kBlacklistAppID);
-    downloader_->StartBlacklistUpdate(
-        prefs_->GetString(kExtensionBlacklistUpdateVersion), ping_data,
-        request_id);
-  }
-
   // StartAllPending() might call OnExtensionDownloadFailed/Finished before
   // it returns, which would cause NotifyIfFinished to incorrectly try to
   // send out a notification. So check before we call StartAllPending if any
   // extensions are going to be updated, and use that to figure out if
   // NotifyIfFinished should be called.
   bool noChecks = request.in_progress_ids_.empty();
 
   // StartAllPending() will call OnExtensionDownloadFailed or
   // OnExtensionDownloadFinished for each extension that was checked.
   downloader_->StartAllPending();
@@ skipping 30 matching lines @@
     // TODO(mek): Somehow increase time between allowing checks when checks
     // are repeatedly throttled and don't result in updates being installed.
 
     // It's okay to start a check, update values.
     info.check_start = now;
     info.in_progress = true;
   }
 
   CheckParams params;
   params.ids.push_back(extension_id);
-  params.check_blacklist = false;
   params.callback = base::Bind(&ExtensionUpdater::ExtensionCheckFinished,
                                weak_ptr_factory_.GetWeakPtr(),
                                extension_id, callback);
   CheckNow(params);
   return true;
 }
 
 void ExtensionUpdater::ExtensionCheckFinished(
     const std::string& extension_id,
     const FinishedCallback& callback) {
@@ skipping 42 matching lines @@
   VLOG(2) << download_url << " written to " << path.value();
 
   FetchedCRXFile fetched(id, path, download_url, request_ids);
   fetched_crx_files_.push(fetched);
 
   // MaybeInstallCRXFile() removes extensions from |in_progress_ids_| after
   // starting the crx installer.
   MaybeInstallCRXFile();
 }
 
-void ExtensionUpdater::OnBlacklistDownloadFinished(
-    const std::string& data,
-    const std::string& package_hash,
-    const std::string& version,
-    const PingResult& ping,
-    const std::set<int>& request_ids) {
-  DCHECK(alive_);
-  UpdatePingData(ExtensionDownloader::kBlacklistAppID, ping);
-  for (std::set<int>::const_iterator it = request_ids.begin();
-       it != request_ids.end(); ++it) {
-    InProgressCheck& request = requests_in_progress_[*it];
-    request.in_progress_ids_.remove(ExtensionDownloader::kBlacklistAppID);
-    NotifyIfFinished(*it);
-  }
-
-  // Verify sha256 hash value.
-  char sha256_hash_value[crypto::kSHA256Length];
-  crypto::SHA256HashString(data, sha256_hash_value, crypto::kSHA256Length);
-  std::string hash_in_hex = base::HexEncode(sha256_hash_value,
-                                            crypto::kSHA256Length);
-
-  if (package_hash != hash_in_hex) {
-    NOTREACHED() << "Fetched blacklist checksum is not as expected. "
-        << "Expected: " << package_hash << " Actual: " << hash_in_hex;
-    return;
-  }
-  std::vector<std::string> blacklist;
-  base::SplitString(data, '\n', &blacklist);
-
-  blacklist_->SetFromUpdater(blacklist, version);
-}
-
 bool ExtensionUpdater::GetPingDataForExtension(
     const std::string& id,
     ManifestFetchData::PingData* ping_data) {
   DCHECK(alive_);
   ping_data->rollcall_days = CalculatePingDays(
       extension_prefs_->LastPingDay(id));
   ping_data->is_enabled = service_->IsExtensionEnabled(id);
   ping_data->active_days =
       CalculateActivePingDays(extension_prefs_->LastActivePingDay(id),
                               extension_prefs_->GetActiveBit(id));
   return true;
 }
 
 std::string ExtensionUpdater::GetUpdateUrlData(const std::string& id) {
   DCHECK(alive_);
   return extension::GetUpdateURLData(extension_prefs_, id);
 }
 
 bool ExtensionUpdater::IsExtensionPending(const std::string& id) {
   DCHECK(alive_);
   return service_->pending_extension_manager()->IsIdPending(id);
 }
 
 bool ExtensionUpdater::GetExtensionExistingVersion(const std::string& id,
                                                    std::string* version) {
   DCHECK(alive_);
-  if (id == ExtensionDownloader::kBlacklistAppID) {
-    *version = prefs_->GetString(kExtensionBlacklistUpdateVersion);
-    return true;
-  }
   const Extension* extension = service_->GetExtensionById(id, true);
   if (!extension)
     return false;
   const Extension* update = service_->GetPendingExtensionUpdate(id);
   if (update)
     *version = update->VersionString();
   else
     *version = extension->VersionString();
   return true;
 }
 
 void ExtensionUpdater::UpdatePingData(const std::string& id,
                                       const PingResult& ping_result) {
   DCHECK(alive_);
-  if (ping_result.did_ping) {
-    if (id == ExtensionDownloader::kBlacklistAppID) {
-      extension_prefs_->SetBlacklistLastPingDay(ping_result.day_start);
-    } else if (service_->GetExtensionById(id, true) != NULL) {
-      extension_prefs_->SetLastPingDay(id, ping_result.day_start);
-    }
-  }
+  if (ping_result.did_ping)
+    extension_prefs_->SetLastPingDay(id, ping_result.day_start);
   if (extension_prefs_->GetActiveBit(id)) {
     extension_prefs_->SetActiveBit(id, false);
     extension_prefs_->SetLastActivePingDay(id, ping_result.day_start);
   }
 }
 
 void ExtensionUpdater::MaybeInstallCRXFile() {
   if (crx_install_is_running_ || fetched_crx_files_.empty())
     return;
 
@@ skipping 94 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions