Don't send extension info for non-webstore extensions during update check

chrome/browser/extensions/updater/extension_updater_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 284 matching lines @@
 }
 
 }  // namespace
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
       : prefs_(prefs),
         pending_extension_manager_(&profile_),
-        downloader_delegate_override_(NULL),
-        enable_metrics_(false) {}
+        downloader_delegate_override_(NULL) {}
 
   ~MockService() override {}
 
   PendingExtensionManager* pending_extension_manager() override {
     ADD_FAILURE() << "Subclass should override this if it will "
                   << "be accessed by a test.";
     return &pending_extension_manager_;
   }
 
   Profile* profile() { return &profile_; }
 
   net::URLRequestContextGetter* request_context() {
     return profile_.GetRequestContext();
   }
 
   ExtensionPrefs* extension_prefs() { return prefs_->prefs(); }
 
   PrefService* pref_service() { return prefs_->pref_service(); }
 
   FakeOAuth2TokenService* fake_token_service() {
     return fake_token_service_.get();
   }
 
-  // Controls whether metrics (enable/disabled state, etc.) are sent in the
-  // autoupdate ping requests.
-  void set_enable_metrics(bool enable) { enable_metrics_ = enable; }
-
   // Creates test extensions and inserts them into list. The name and
   // version are all based on their index. If |update_url| is non-null, it
   // will be used as the update_url for each extension.
   // The |id| is used to distinguish extension names and make sure that
   // no two extensions share the same name.
   void CreateTestExtensions(int id, int count, ExtensionList *list,
                             const std::string* update_url,
                             Manifest::Location location) {
     for (int i = 1; i <= count; i++) {
       base::DictionaryValue manifest;
@@ skipping 30 matching lines @@
   PendingExtensionManager pending_extension_manager_;
 
  private:
   std::unique_ptr<ExtensionDownloader> CreateExtensionDownloader(
       ExtensionDownloaderDelegate* delegate) {
     std::unique_ptr<ExtensionDownloader> downloader =
         ChromeExtensionDownloaderFactory::CreateForRequestContext(
             request_context(), downloader_delegate_override_
                                    ? downloader_delegate_override_
                                    : delegate);
-    if (enable_metrics_)
-      downloader->set_enable_extra_update_metrics(true);
     return downloader;
   }
 
   std::unique_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
       ExtensionDownloaderDelegate* delegate) {
     std::unique_ptr<FakeIdentityProvider> fake_identity_provider;
     fake_token_service_.reset(new FakeOAuth2TokenService());
     fake_identity_provider.reset(new FakeIdentityProvider(
           fake_token_service_.get()));
     fake_identity_provider->LogIn(kFakeAccountId);
     fake_token_service_->AddAccount(kFakeAccountId);
 
     std::unique_ptr<ExtensionDownloader> downloader(
         CreateExtensionDownloader(delegate));
     downloader->SetWebstoreIdentityProvider(std::move(fake_identity_provider));
     return downloader;
   }
 
   std::unique_ptr<FakeOAuth2TokenService> fake_token_service_;
 
   ExtensionDownloaderDelegate* downloader_delegate_override_;
 
-  bool enable_metrics_;
-
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 
 bool ShouldInstallExtensionsOnly(const Extension* extension) {
   return extension->GetType() == Manifest::TYPE_EXTENSION;
 }
 
 bool ShouldInstallThemesOnly(const Extension* extension) {
   return extension->is_theme();
@@ skipping 1851 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions