Adding logging of offstore extensions state to user metrics.

chrome/browser/metrics/extensions_metrics_provider.cc

 // Copyright 2014 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/metrics/extensions_metrics_provider.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/install_verifier.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/common/extension_set.h"
 #include "third_party/smhasher/src/City.h"
 
 namespace {
 
 // The number of possible hash keys that a client may use.  The UMA client_id
 // value is reduced modulo this value to produce the key used by that
 // particular client.
 const size_t kExtensionListClientKeys = 4096;
 
 // The number of hash buckets into which extension IDs are mapped.  This sets
 // the possible output range of the HashExtension function.
 const size_t kExtensionListBuckets = 1024;
 
+enum ExtensionState {
+  NO_EXTENSIONS,
+  FROM_STORE_VERIFIED,
+  FROM_STORE_UNVERIFIED,
+  OFF_STORE

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Can you use the proto's enum directly instead of this extra enum and a
conversion function?

I guess the reason you don't do this is so you can have the max() logic in the
loops below. If that's the intention, please document that in a comment on this
enum (so that if add new values, we'll preserve such an ordering).

[jwd, 2014/08/12 18:45:28]

Done.

+};
+
+metrics::SystemProfileProto::ExtensionsState ExtensionStateAsProto(
+    ExtensionState value) {
+  switch (value) {
+    case NO_EXTENSIONS:
+      return metrics::SystemProfileProto::NO_EXTENSIONS;
+    case FROM_STORE_VERIFIED:
+      return metrics::SystemProfileProto::NO_OFFSTORE_VERIFIED;
+    case FROM_STORE_UNVERIFIED:
+      return metrics::SystemProfileProto::NO_OFFSTORE_UNVERIFIED;
+    case OFF_STORE:
+      return metrics::SystemProfileProto::HAS_OFFSTORE;
+  }
+  NOTREACHED();
+  return metrics::SystemProfileProto::NO_EXTENSIONS;
+}
+
+// Determines if the |extension| is an extension (can use extension APIs) and is
+// not from the webstore. If local information claims the extension is from the
+// webstore, we attempt to verifie with the |InstallVerifier| by checking if it

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: verify

[jwd, 2014/08/12 18:45:28]

Done.

+// has been explicitly deemed invalid. If the |InstallVerifier| is inactive or

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: No need for |'s around InstallVerifier since it's a class name. You can
alternatively change to |verifier| if you want, but I don't have a preference
here.

[jwd, 2014/08/12 18:45:28]

Done.

+// if the extension is unknown to the |InstallVerifier|, the local information
+// is trusted.
+ExtensionState IsOffStoreExtension(
+    const extensions::Extension& extension,
+    const extensions::InstallVerifier& verifier) {
+  if (!extension.is_extension() && !extension.is_legacy_packaged_app())
+    return NO_EXTENSIONS;
+
+  // Component extensions are considered safe.
+  if (extension.location() == extensions::Manifest::COMPONENT ||
+      extension.location() == extensions::Manifest::EXTERNAL_COMPONENT) {
+    return NO_EXTENSIONS;
+  }
+
+  if (verifier.AllowedByEnterprisePolicy(extension.id()))
+    return NO_EXTENSIONS;
+
+  if (!extensions::InstallVerifier::FromStore(extension))
+    return OFF_STORE;
+
+  // Local information about the extension implies it is from the store. We try
+  // to use the install verifier to vereify this.
+  if (!verifier.IsKnownId(extension.id()))
+    return FROM_STORE_UNVERIFIED;
+
+  if (verifier.IsInvalid(extension.id()))
+    return OFF_STORE;
+  else

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: Remove else and unindent return below.

[jwd, 2014/08/12 18:45:28]

Done.

+    return FROM_STORE_VERIFIED;
+}
+
+ExtensionState CheckForOffStore(const extensions::ExtensionSet& extensions,
+                                const extensions::InstallVerifier& verifier) {
+  ExtensionState extensions_state = NO_EXTENSIONS;
+  for (extensions::ExtensionSet::const_iterator it = extensions.begin();
+       it != extensions.end();
+       ++it) {

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: for (size_t i = 0; i < extensions.size(); ++i) is 2 lines shorter. Same
below.

[jwd, 2014/08/12 18:45:28]

Done below, not done her as discussed.

+    extensions_state =
+        std::max(extensions_state, IsOffStoreExtension(**it, verifier));
+  }
+  return extensions_state;
+}
+
 }  // namespace
 
 ExtensionsMetricsProvider::ExtensionsMetricsProvider(
     metrics::MetricsStateManager* metrics_state_manager)
     : metrics_state_manager_(metrics_state_manager), cached_profile_(NULL) {
   DCHECK(metrics_state_manager_);
 }
 
 ExtensionsMetricsProvider::~ExtensionsMetricsProvider() {
 }
@@ skipping 25 matching lines @@
   cached_profile_ = profile_manager->GetProfileByPath(
       profile_manager->GetLastUsedProfileDir(profile_manager->user_data_dir()));
   if (cached_profile_) {
     // Ensure that the returned profile is not an incognito profile.
     cached_profile_ = cached_profile_->GetOriginalProfile();
   }
   return cached_profile_;
 }
 
 scoped_ptr<extensions::ExtensionSet>
-ExtensionsMetricsProvider::GetInstalledExtensions() {
+ExtensionsMetricsProvider::GetInstalledExtensions(Profile* profile) {
 #if defined(ENABLE_EXTENSIONS)
-  // UMA reports do not support multiple profiles, but extensions are installed
-  // per-profile.  We return the extensions installed in the primary profile.
-  // In the future, we might consider reporting data about extensions in all
-  // profiles.
-  Profile* profile = GetMetricsProfile();
   if (profile) {
     return extensions::ExtensionRegistry::Get(profile)
         ->GenerateInstalledExtensionsSet();
   }
 #endif  // defined(ENABLE_EXTENSIONS)
   return scoped_ptr<extensions::ExtensionSet>();
 }
 
 uint64 ExtensionsMetricsProvider::GetClientID() {
   // TODO(blundell): Create a MetricsLog::ClientIDAsInt() API and call it
   // here as well as in MetricsLog's population of the client_id field of
   // the uma_proto.
   return MetricsLog::Hash(metrics_state_manager_->client_id());
 }
 
 void ExtensionsMetricsProvider::ProvideSystemProfileMetrics(
     metrics::SystemProfileProto* system_profile) {
-  scoped_ptr<extensions::ExtensionSet> extensions(GetInstalledExtensions());
+  ProvideOffStoreMetric(system_profile);
+  ProvideOccupiedBucketMetric(system_profile);
+}
+
+void ExtensionsMetricsProvider::ProvideOffStoreMetric(
+    metrics::SystemProfileProto* system_profile) {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  if (!profile_manager)
+    return;
+
+  ExtensionState extensions_state = NO_EXTENSIONS;
+
+  std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();

[Alexei Svitkine (slow), 2014/08/12 15:22:40]

Add a comment explaining how we treat multi-profiles.

[jwd, 2014/08/12 18:45:28]

Done.

+  for (std::vector<Profile*>::const_iterator it = profiles.begin();
+       it != profiles.end();
+       ++it) {
+    extensions::InstallVerifier* verifier =
+        extensions::ExtensionSystem::Get(*it)->install_verifier();
+
+    scoped_ptr<extensions::ExtensionSet> extensions(
+        GetInstalledExtensions(*it));
+
+    extensions_state = std::max(extensions_state,

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: This deserves a comment.

[Alexei Svitkine (slow), 2014/08/12 15:22:39]

Nit: Add a comment about the max() logic.

[jwd, 2014/08/12 18:45:28]

Done.

[jwd, 2014/08/12 18:45:28]

Done.

+                                CheckForOffStore(*extensions.get(), *verifier));
+  }
+
+  system_profile->set_offstore_extensions_state(
+      ExtensionStateAsProto(extensions_state));
+}
+
+void ExtensionsMetricsProvider::ProvideOccupiedBucketMetric(
+    metrics::SystemProfileProto* system_profile) {
+  // UMA reports do not support multiple profiles, but extensions are installed
+  // per-profile.  We return the extensions installed in the primary profile.
+  // In the future, we might consider reporting data about extensions in all
+  // profiles.
+  Profile* profile = GetMetricsProfile();
+
+  scoped_ptr<extensions::ExtensionSet> extensions(
+      GetInstalledExtensions(profile));
   if (!extensions)
     return;
 
   const int client_key = GetClientID() % kExtensionListClientKeys;
 
   std::set<int> buckets;
   for (extensions::ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end();
        ++it) {
     buckets.insert(HashExtension((*it)->id(), client_key));
   }
 
   for (std::set<int>::const_iterator it = buckets.begin(); it != buckets.end();
        ++it) {
     system_profile->add_occupied_extension_bucket(*it);
   }
 }