Enable Activity Logging by default

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"
@@ skipping 165 matching lines @@
 
 // ActivityLog
 
 // SET THINGS UP. --------------------------------------------------------------
 
 // Use GetInstance instead of directly creating an ActivityLog.
 ActivityLog::ActivityLog(Profile* profile)
     : policy_(NULL),
       policy_type_(ActivityLogPolicy::POLICY_INVALID),
       profile_(profile),
-      enabled_(false),
-      policy_chosen_(false),
+      db_enabled_(false),
       testing_mode_(false),
       has_threads_(true),
       tracker_(NULL),
-      watchdog_extension_active_(false) {
-  // This controls whether logging statements are printed, which policy is set,
-  // etc.
+      watchdog_app_active_(false) {
+  // 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.
-  watchdog_extension_active_ =
+  watchdog_app_active_ =
     profile_->GetPrefs()->GetBoolean(prefs::kWatchdogExtensionActive);
 
   observers_ = new ObserverListThreadSafe<Observer>;
 
-  // Check that the right threads exist. If not, we shouldn't try to do things
-  // that require them.
+  // Check that the right threads exist for logging to the database.
+  // If not, we shouldn't try to do things that require them.
   if (!BrowserThread::IsMessageLoopValid(BrowserThread::DB) ||
       !BrowserThread::IsMessageLoopValid(BrowserThread::FILE) ||
       !BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
-    LOG(ERROR) << "Missing threads, disabling Activity Logging!";
     has_threads_ = false;
   }
 
-  enabled_ = has_threads_
+  db_enabled_ = has_threads_
       && (CommandLine::ForCurrentProcess()->
           HasSwitch(switches::kEnableExtensionActivityLogging)
-      || watchdog_extension_active_);
-
-  if (enabled_) enabled_on_any_profile_ = true;
+      || watchdog_app_active_);
 
   ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(&ActivityLog::InitInstallTracker, base::Unretained(this)));
   ChooseDefaultPolicy();
 }
 
 void ActivityLog::SetDefaultPolicy(ActivityLogPolicy::PolicyType policy_type) {
-  // Can't use IsLogEnabled() here because this is called from inside Init.
-  if (policy_type != policy_type_ && enabled_) {
-    // Deleting the old policy takes place asynchronously, on the database
-    // thread.  Initializing a new policy below similarly happens
-    // asynchronously.  Since the two operations are both queued for the
-    // database, the queue ordering should ensure that the deletion completes
-    // before database initialization occurs.
-    //
-    // However, changing policies at runtime is still not recommended, and
-    // likely only should be done for unit tests.
-    if (policy_)
-      policy_->Close();
+  if (policy_type == policy_type_)
+    return;
+  if (!IsDatabaseEnabled() && !IsWatchdogAppActive())
+    return;
 
-    switch (policy_type) {
-      case ActivityLogPolicy::POLICY_FULLSTREAM:
-        policy_ = new FullStreamUIPolicy(profile_);
-        break;
-      case ActivityLogPolicy::POLICY_COUNTS:
-        policy_ = new CountingPolicy(profile_);
-        break;
-      default:
-        NOTREACHED();
-    }
-    policy_type_ = policy_type;
+  // Deleting the old policy takes place asynchronously, on the database
+  // thread.  Initializing a new policy below similarly happens
+  // asynchronously.  Since the two operations are both queued for the
+  // database, the queue ordering should ensure that the deletion completes
+  // before database initialization occurs.
+  //
+  // However, changing policies at runtime is still not recommended, and
+  // likely only should be done for unit tests.
+  if (policy_)
+    policy_->Close();
+
+  switch (policy_type) {
+    case ActivityLogPolicy::POLICY_FULLSTREAM:
+      policy_ = new FullStreamUIPolicy(profile_);
+      break;
+    case ActivityLogPolicy::POLICY_COUNTS:
+      policy_ = new CountingPolicy(profile_);
+      break;
+    default:
+      NOTREACHED();
   }
+  policy_type_ = policy_type;
 }
 
 // SHUT DOWN. ------------------------------------------------------------------
 
 void ActivityLog::Shutdown() {
   if (tracker_) tracker_->RemoveObserver(this);
 }
 
 ActivityLog::~ActivityLog() {
   if (policy_)
     policy_->Close();
 }
 
 // MAINTAIN STATUS. ------------------------------------------------------------
 
 void ActivityLog::InitInstallTracker() {
   tracker_ = InstallTrackerFactory::GetForProfile(profile_);
   tracker_->AddObserver(this);
 }
 
 void ActivityLog::ChooseDefaultPolicy() {
-  if (policy_chosen_ || !enabled_) return;
+  if (!(IsDatabaseEnabled() || IsWatchdogAppActive()))
+    return;
   if (testing_mode_)
     SetDefaultPolicy(ActivityLogPolicy::POLICY_FULLSTREAM);
   else
     SetDefaultPolicy(ActivityLogPolicy::POLICY_COUNTS);
 }
 
-// static
-bool ActivityLog::enabled_on_any_profile_ = false;
-
-// static
-bool ActivityLog::IsLogEnabledOnAnyProfile() {
-  return enabled_on_any_profile_;
+bool ActivityLog::IsDatabaseEnabled() {
+  // Make sure we are not enabled when there are no threads.
+  DCHECK(has_threads_ || !db_enabled_);
+  return db_enabled_;
 }
 
-bool ActivityLog::IsLogEnabled() {
-  // Make sure we are not enabled when there are no threads.
-  DCHECK(has_threads_ || !enabled_);
-  return enabled_;
+bool ActivityLog::IsWatchdogAppActive() {
+  return watchdog_app_active_;
+}
+
+void ActivityLog::SetWatchdogAppActive(bool active) {
+  watchdog_app_active_ = active;
 }
 
 void ActivityLog::OnExtensionLoaded(const Extension* extension) {
   if (extension->id() != kActivityLogExtensionId) return;
-  if (has_threads_) {
-    enabled_ = true;
-    enabled_on_any_profile_ = true;
-  }
-  if (!watchdog_extension_active_) {
-    watchdog_extension_active_ = true;
+  if (has_threads_)
+    db_enabled_ = true;
+  if (!watchdog_app_active_) {
+    watchdog_app_active_ = true;
     profile_->GetPrefs()->SetBoolean(prefs::kWatchdogExtensionActive, true);
   }
   ChooseDefaultPolicy();
 }
 
 void ActivityLog::OnExtensionUnloaded(const Extension* extension) {
   if (extension->id() != kActivityLogExtensionId) return;
-  // Make sure we are not enabled when there are no threads.
-  DCHECK(has_threads_ || !enabled_);
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableExtensionActivityLogging))
-    enabled_ = false;
-  if (watchdog_extension_active_) {
-    watchdog_extension_active_ = false;
+      switches::kEnableExtensionActivityLogging)) {
+    db_enabled_ = false;
+  }
+  if (watchdog_app_active_) {
+    watchdog_app_active_ = false;
     profile_->GetPrefs()->SetBoolean(prefs::kWatchdogExtensionActive,
                                      false);
   }
 }
 
 // static
 ActivityLog* ActivityLog::GetInstance(Profile* profile) {
   return ActivityLogFactory::GetForProfile(profile);
 }
 
@@ skipping 10 matching lines @@
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kWatchdogExtensionActive,
       false,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // LOG ACTIONS. ----------------------------------------------------------------
 
 void ActivityLog::LogAction(scoped_refptr<Action> action) {
-  if (!IsLogEnabled() ||
-      ActivityLogAPI::IsExtensionWhitelisted(action->extension_id()))
+  if (ActivityLogAPI::IsExtensionWhitelisted(action->extension_id()))
     return;
 
   // Perform some preprocessing of the Action data: convert tab IDs to URLs and
   // mask out incognito URLs if appropriate.
   if ((action->action_type() == Action::ACTION_API_CALL ||
        action->action_type() == Action::ACTION_API_EVENT) &&
       StartsWithASCII(action->api_name(), "tabs.", true)) {
     LookupTabIds(action, profile_);
   }
 
   // TODO(mvrable): Add any necessary processing of incognito URLs here, for
   // crbug.com/253368
 
-  if (policy_)
+  if (IsDatabaseEnabled() && policy_)
     policy_->ProcessAction(action);
-  observers_->Notify(&Observer::OnExtensionActivity, action);
+  if (IsWatchdogAppActive())
+    observers_->Notify(&Observer::OnExtensionActivity, action);
   if (testing_mode_)
     LOG(INFO) << action->PrintForDebug();
 }
 
 void ActivityLog::OnScriptsExecuted(
     const content::WebContents* web_contents,
     const ExecutingScriptsMap& extension_ids,
     int32 on_page_id,
     const GURL& on_url) {
-  if (!IsLogEnabled()) return;
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   const ExtensionService* extension_service =
       ExtensionSystem::Get(profile)->extension_service();
   const ExtensionSet* extensions = extension_service->extensions();
   const prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()));
 
   for (ExecutingScriptsMap::const_iterator it = extension_ids.begin();
@@ skipping 50 matching lines @@
         <void(scoped_ptr<std::vector<scoped_refptr<Action> > >)>& callback) {
   if (policy_) {
     policy_->ReadFilteredData(
         extension_id, type, api_name, page_url, arg_url, callback);
   }
 }
 
 // DELETE ACTIONS. -------------------------------------------------------------
 
 void ActivityLog::RemoveURLs(const std::vector<GURL>& restrict_urls) {
-  if (!policy_ || !IsLogEnabled()) {
+  if (!policy_)
     return;
-  }
   policy_->RemoveURLs(restrict_urls);
 }
 
 void ActivityLog::RemoveURLs(const std::set<GURL>& restrict_urls) {
-  if (!policy_ || !IsLogEnabled()) {
+  if (!policy_)
     return;
-  }
 
   std::vector<GURL> urls;
   for (std::set<GURL>::const_iterator it = restrict_urls.begin();
        it != restrict_urls.end(); ++it) {
     urls.push_back(*it);
   }
   policy_->RemoveURLs(urls);
 }
 
 void ActivityLog::RemoveURL(const GURL& url) {
   if (url.is_empty())
     return;
   std::vector<GURL> urls;
   urls.push_back(url);
   RemoveURLs(urls);
 }
 
 }  // namespace extensions