Remove InstallTracker's extension load, unload observer

chrome/browser/extensions/activity_log/activity_log.cc

 // Copyright (c) 2011 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/activity_log/activity_log.h"
 
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
 #include "chrome/browser/extensions/activity_log/counting_policy.h"
 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/extensions/install_tracker.h"
-#include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_registry_factory.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/one_shot_event.h"
 #include "third_party/re2/re2/re2.h"
 #include "url/gurl.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/extensions/activity_log/uma_policy.h"
@@ skipping 309 matching lines @@
 
 // Use GetInstance instead of directly creating an ActivityLog.
 ActivityLog::ActivityLog(content::BrowserContext* context)
     : database_policy_(NULL),
       database_policy_type_(ActivityLogPolicy::POLICY_INVALID),
       uma_policy_(NULL),
       profile_(Profile::FromBrowserContext(context)),
       db_enabled_(false),
       testing_mode_(false),
       has_threads_(true),
-      tracker_(NULL),
+      extension_registry_observer_(this),
       watchdog_apps_active_(0) {
   // This controls whether logging statements are printed & which policy is set.
   testing_mode_ = CommandLine::ForCurrentProcess()->HasSwitch(
     switches::kEnableExtensionActivityLogTesting);
 
   // Check if the watchdog extension is previously installed and active.
   // It was originally a boolean, but we've had to move to an integer. Handle
   // the legacy case.
   // TODO(felt): In M34, remove the legacy code & old pref.
   if (profile_->GetPrefs()->GetBoolean(prefs::kWatchdogExtensionActiveOld))
@@ skipping 11 matching lines @@
     has_threads_ = false;
   }
 
   db_enabled_ = has_threads_
       && (CommandLine::ForCurrentProcess()->
           HasSwitch(switches::kEnableExtensionActivityLogging)
       || watchdog_apps_active_);
 
   ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
-      base::Bind(&ActivityLog::InitInstallTracker, base::Unretained(this)));
+      base::Bind(&ActivityLog::StartObserving, base::Unretained(this)));
 
 // None of this should run on Android since the AL is behind ENABLE_EXTENSION
 // checks. However, UmaPolicy can't even compile on Android because it uses
 // BrowserList and related classes that aren't compiled for Android.
 #if !defined(OS_ANDROID)
   if (!profile_->IsOffTheRecord())
     uma_policy_ = new UmaPolicy(profile_);
 #endif
 
   ChooseDatabasePolicy();
@@ skipping 24 matching lines @@
     case ActivityLogPolicy::POLICY_COUNTS:
       database_policy_ = new CountingPolicy(profile_);
       break;
     default:
       NOTREACHED();
   }
   database_policy_->Init();
   database_policy_type_ = policy_type;
 }
 
-// SHUT DOWN. ------------------------------------------------------------------
-
-void ActivityLog::Shutdown() {
-  if (tracker_) tracker_->RemoveObserver(this);
-}
-
 ActivityLog::~ActivityLog() {
   if (uma_policy_)
     uma_policy_->Close();
   if (database_policy_)
     database_policy_->Close();
 }
 
 // MAINTAIN STATUS. ------------------------------------------------------------
 
-void ActivityLog::InitInstallTracker() {
-  tracker_ = InstallTrackerFactory::GetForProfile(profile_);
-  tracker_->AddObserver(this);
+void ActivityLog::StartObserving() {
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 }
 
 void ActivityLog::ChooseDatabasePolicy() {
   if (!(IsDatabaseEnabled() || IsWatchdogAppActive()))
     return;
   if (testing_mode_)
     SetDatabasePolicy(ActivityLogPolicy::POLICY_FULLSTREAM);
   else
     SetDatabasePolicy(ActivityLogPolicy::POLICY_COUNTS);
 }
 
 bool ActivityLog::IsDatabaseEnabled() {
   // Make sure we are not enabled when there are no threads.
   DCHECK(has_threads_ || !db_enabled_);
   return db_enabled_;
 }
 
 bool ActivityLog::IsWatchdogAppActive() {
   return (watchdog_apps_active_ > 0);
 }
 
 void ActivityLog::SetWatchdogAppActiveForTesting(bool active) {
   watchdog_apps_active_ = active ? 1 : 0;
 }
 
-void ActivityLog::OnExtensionLoaded(const Extension* extension) {
+void ActivityLog::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                    const Extension* extension) {
   if (!ActivityLogAPI::IsExtensionWhitelisted(extension->id())) return;
   if (has_threads_)
     db_enabled_ = true;
   watchdog_apps_active_++;
   profile_->GetPrefs()->SetInteger(prefs::kWatchdogExtensionActive,
                                    watchdog_apps_active_);
   if (watchdog_apps_active_ == 1)
     ChooseDatabasePolicy();
 }
 
-void ActivityLog::OnExtensionUnloaded(const Extension* extension) {
+void ActivityLog::OnExtensionUnloaded(content::BrowserContext* browser_context,
+                                      const Extension* extension,
+                                      UnloadedExtensionInfo::Reason reason) {
   if (!ActivityLogAPI::IsExtensionWhitelisted(extension->id())) return;
   watchdog_apps_active_--;
   profile_->GetPrefs()->SetInteger(prefs::kWatchdogExtensionActive,
                                    watchdog_apps_active_);
   if (watchdog_apps_active_ == 0 &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExtensionActivityLogging)) {
     db_enabled_ = false;
   }
 }
 
 // OnExtensionUnloaded will also be called right before this.
-void ActivityLog::OnExtensionUninstalled(const Extension* extension) {
+void ActivityLog::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
   if (ActivityLogAPI::IsExtensionWhitelisted(extension->id()) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExtensionActivityLogging) &&
       watchdog_apps_active_ == 0) {
     DeleteDatabase();
   } else if (database_policy_) {
     database_policy_->RemoveExtensionData(extension->id());
   }
 }
 
@@ skipping 171 matching lines @@
 
 void ActivityLog::DeleteDatabase() {
   if (!database_policy_)
     return;
   database_policy_->DeleteDatabase();
 }
 
 template <>
 void BrowserContextKeyedAPIFactory<ActivityLog>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
-  DependsOn(InstallTrackerFactory::GetInstance());
+  DependsOn(ExtensionRegistryFactory::GetInstance());
 }
 
 }  // namespace extensions