Adding logging of offstore extensions state to user metrics.

chrome/browser/extensions/install_verifier.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/extensions/install_verifier.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
   // the "MAX" item below should always be the last element.
 
   INIT_RESULT_MAX
 };
 
 void LogInitResultHistogram(InitResult result) {
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.InitResult",
                             result, INIT_RESULT_MAX);
 }
 
-bool FromStore(const Extension& extension) {
-  if (extension.from_webstore() || ManifestURL::UpdatesFromGallery(&extension))
-    return true;
-
-  // If an extension has no update url, our autoupdate code will ask the
-  // webstore about it (to aid in migrating to the webstore from self-hosting
-  // or sideloading based installs). So we want to do verification checks on
-  // such extensions too so that we don't accidentally disable old installs of
-  // extensions that did migrate to the webstore.
-  return (ManifestURL::GetUpdateURL(&extension).is_empty() &&
-          Manifest::IsAutoUpdateableLocation(extension.location()));
-}
-
 bool CanUseExtensionApis(const Extension& extension) {
   return extension.is_extension() || extension.is_legacy_packaged_app();
 }
 
 enum VerifyAllSuccess {
   VERIFY_ALL_BOOTSTRAP_SUCCESS = 0,
   VERIFY_ALL_BOOTSTRAP_FAILURE,
   VERIFY_ALL_NON_BOOTSTRAP_SUCCESS,
   VERIFY_ALL_NON_BOOTSTRAP_FAILURE,
 
@@ skipping 35 matching lines @@
     : prefs_(prefs),
       context_(context),
       bootstrap_check_complete_(false),
       weak_factory_(this) {
 }
 
 InstallVerifier::~InstallVerifier() {}
 
 // static
 bool InstallVerifier::NeedsVerification(const Extension& extension) {
-  return FromStore(extension) && CanUseExtensionApis(extension);
+  return IsFromStore(extension) && CanUseExtensionApis(extension);
+}
+
+
+
+// static
+bool InstallVerifier::IsFromStore(const Extension& extension) {
+  if (extension.from_webstore() || ManifestURL::UpdatesFromGallery(&extension))
+    return true;
+
+  // If an extension has no update url, our autoupdate code will ask the
+  // webstore about it (to aid in migrating to the webstore from self-hosting
+  // or sideloading based installs). So we want to do verification checks on
+  // such extensions too so that we don't accidentally disable old installs of
+  // extensions that did migrate to the webstore.
+  return (ManifestURL::GetUpdateURL(&extension).is_empty() &&
+          Manifest::IsAutoUpdateableLocation(extension.location()));
 }
 
 void InstallVerifier::Init() {
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ExperimentStatus",
                             GetExperimentStatus(), VERIFY_STATUS_MAX);
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ActualStatus",
                             GetStatus(), VERIFY_STATUS_MAX);
 
   const base::DictionaryValue* pref = prefs_->GetInstallSignature();
   if (pref) {
@@ skipping 25 matching lines @@
   AddMany(GetExtensionsToVerify(), ADD_ALL);
 }
 
 base::Time InstallVerifier::SignatureTimestamp() {
   if (signature_.get())
     return signature_->timestamp;
   else
     return base::Time();
 }
 
-bool InstallVerifier::IsKnownId(const std::string& id) {
+bool InstallVerifier::IsKnownId(const std::string& id) const {
   return signature_.get() && (ContainsKey(signature_->ids, id) ||
                               ContainsKey(signature_->invalid_ids, id));
 }
 
+bool InstallVerifier::IsInvalid(const std::string& id) const {
+  return ((signature_.get() && ContainsKey(signature_->invalid_ids, id)));
+}
+
 void InstallVerifier::VerifyExtension(const std::string& extension_id) {
   ExtensionIdSet ids;
   ids.insert(extension_id);
   AddMany(ids, ADD_SINGLE);
 }
 
 void InstallVerifier::AddMany(const ExtensionIdSet& ids, OperationType type) {
   if (!ShouldFetchSignature()) {
     OnVerificationComplete(true, type);  // considered successful.
     return;
@@ skipping 47 matching lines @@
 
   InstallVerifier::PendingOperation* operation =
       new InstallVerifier::PendingOperation(InstallVerifier::REMOVE);
   operation->ids = ids;
 
   operation_queue_.push(linked_ptr<PendingOperation>(operation));
   if (operation_queue_.size() == 1)
     BeginFetch();
 }
 
+bool InstallVerifier::AllowedByEnterprisePolicy(const std::string& id) const {
+  PrefService* pref_service = prefs_->pref_service();
+  if (pref_service->IsManagedPreference(pref_names::kInstallAllowList)) {
+    const base::ListValue* whitelist =
+        pref_service->GetList(pref_names::kInstallAllowList);
+    base::StringValue id_value(id);
+    if (whitelist && whitelist->Find(id_value) != whitelist->end())
+      return true;
+  }
+  if (pref_service->IsManagedPreference(pref_names::kInstallForceList)) {
+    const base::DictionaryValue* forcelist =
+        pref_service->GetDictionary(pref_names::kInstallForceList);
+    if (forcelist && forcelist->HasKey(id))
+      return true;
+  }
+  return false;
+}
+
 std::string InstallVerifier::GetDebugPolicyProviderName() const {
   return std::string("InstallVerifier");
 }
 
 namespace {
 
 enum MustRemainDisabledOutcome {
   VERIFIED = 0,
   NOT_EXTENSION,
   UNPACKED,
@@ skipping 38 matching lines @@
   if (AllowedByEnterprisePolicy(extension->id())) {
     MustRemainDisabledHistogram(ENTERPRISE_POLICY_ALLOWED);
     return false;
   }
 
   bool verified = true;
   MustRemainDisabledOutcome outcome = VERIFIED;
   if (ContainsKey(InstallSigner::GetForcedNotFromWebstore(), extension->id())) {
     verified = false;
     outcome = FORCED_NOT_VERIFIED;
-  } else if (!FromStore(*extension)) {
+  } else if (!IsFromStore(*extension)) {
     verified = false;
     outcome = NOT_FROM_STORE;
   } else if (signature_.get() == NULL &&
              (!bootstrap_check_complete_ || GetStatus() < ENFORCE_STRICT)) {
     // If we don't have a signature yet, we'll temporarily consider every
     // extension from the webstore verified to avoid false positives on existing
     // profiles hitting this code for the first time. The InstallVerifier
     // will bootstrap itself once the ExtensionsSystem is ready.
     outcome = NO_SIGNATURE;
   } else if (!IsVerified(extension->id())) {
@@ skipping 117 matching lines @@
        i != all_ids.end(); ++i) {
     ExtensionIdSet::iterator found = leftovers.find(*i);
     if (found != leftovers.end())
       leftovers.erase(found);
   }
   if (!leftovers.empty()) {
     RemoveMany(leftovers);
   }
 }
 
-bool InstallVerifier::AllowedByEnterprisePolicy(const std::string& id) const {
-  PrefService* pref_service = prefs_->pref_service();
-  if (pref_service->IsManagedPreference(pref_names::kInstallAllowList)) {
-    const base::ListValue* whitelist =
-        pref_service->GetList(pref_names::kInstallAllowList);
-    base::StringValue id_value(id);
-    if (whitelist && whitelist->Find(id_value) != whitelist->end())
-      return true;
-  }
-  if (pref_service->IsManagedPreference(pref_names::kInstallForceList)) {
-    const base::DictionaryValue* forcelist =
-        pref_service->GetDictionary(pref_names::kInstallForceList);
-    if (forcelist && forcelist->HasKey(id))
-      return true;
-  }
-  return false;
-}
-
 bool InstallVerifier::IsVerified(const std::string& id) const {
   return ((signature_.get() && ContainsKey(signature_->ids, id)) ||
           ContainsKey(provisional_, id));
 }
 
 void InstallVerifier::BeginFetch() {
   DCHECK(ShouldFetchSignature());
 
   // TODO(asargent) - It would be possible to coalesce all operations in the
   // queue into one fetch - we'd probably just need to change the queue to
@@ skipping 94 matching lines @@
     }
 
     OnVerificationComplete(success, operation->type);
   }
 
   if (!operation_queue_.empty())
     BeginFetch();
 }
 
 }  // namespace extensions