Sets correct ActivityLog enabled status to the first renderer process

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/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/stream_noargs_ui_policy.h"
 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/extension_tab_util.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/incognito_helpers.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/pref_names.h"
 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/re2/re2/re2.h"
 #include "url/gurl.h"
 
 namespace constants = activity_log_constants;
 
 namespace {
 
 // Concatenate arguments.
 std::string MakeArgList(const base::ListValue* args) {
   std::string call_signature;
   base::ListValue::const_iterator it = args->begin();
   for (; it != args->end(); ++it) {
     std::string arg;
     JSONStringValueSerializer serializer(&arg);
     if (serializer.SerializeAndOmitBinaryValues(**it)) {
       if (it != args->begin())
         call_signature += ", ";
       call_signature += arg;
     }
   }
   return call_signature;
 }
 
-// This is a hack for AL callers who don't have access to a profile object
-// when deciding whether or not to do the work required for logging. The state
-// is accessed through the static ActivityLog::IsLogEnabledOnAnyProfile()
-// method. It returns true if --enable-extension-activity-logging is set on the
-// command line OR *ANY* profile has the activity log whitelisted extension
-// installed.
-class LogIsEnabled {
- public:
-  LogIsEnabled() : any_profile_enabled_(false) {
-    ComputeIsFlagEnabled();
-  }
-
-  void ComputeIsFlagEnabled() {
-    base::AutoLock auto_lock(lock_);
-    cmd_line_enabled_ = CommandLine::ForCurrentProcess()->
-        HasSwitch(switches::kEnableExtensionActivityLogging);
-  }
-
-  static LogIsEnabled* GetInstance() {
-    return Singleton<LogIsEnabled>::get();
-  }
-
-  bool IsEnabled() {
-    base::AutoLock auto_lock(lock_);
-    return cmd_line_enabled_ || any_profile_enabled_;
-  }
-
-  void SetProfileEnabled(bool any_profile_enabled) {
-    base::AutoLock auto_lock(lock_);
-    any_profile_enabled_ = any_profile_enabled;
-  }
-
- private:
-  base::Lock lock_;
-  bool any_profile_enabled_;
-  bool cmd_line_enabled_;
-};
-
 // Gets the URL for a given tab ID.  Helper method for LookupTabId.  Returns
 // true if able to perform the lookup.  The URL is stored to *url, and
 // *is_incognito is set to indicate whether the URL is for an incognito tab.
 bool GetUrlForTabId(int tab_id,
                     Profile* profile,
                     GURL* url,
                     bool* is_incognito) {
   content::WebContents* contents = NULL;
   Browser* browser = NULL;
   bool found = ExtensionTabUtil::GetTabById(tab_id,
@@ skipping 71 matching lines @@
         }
       }
     }
   }
 }
 
 }  // namespace
 
 namespace extensions {
 
-// static
-bool ActivityLog::IsLogEnabledOnAnyProfile() {
-  return LogIsEnabled::GetInstance()->IsEnabled();
-}
-
-// static
-void ActivityLog::RecomputeLoggingIsEnabled(bool profile_enabled) {
-  LogIsEnabled::GetInstance()->ComputeIsFlagEnabled();
-  LogIsEnabled::GetInstance()->SetProfileEnabled(profile_enabled);
-}
-
 // ActivityLogFactory
 
 ActivityLogFactory* ActivityLogFactory::GetInstance() {
   return Singleton<ActivityLogFactory>::get();
 }
 
 BrowserContextKeyedService* ActivityLogFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new ActivityLog(static_cast<Profile*>(profile));
 }
@@ skipping 43 matching lines @@
     policy_type_ = policy_type;
   }
 }
 
 // Use GetInstance instead of directly creating an ActivityLog.
 ActivityLog::ActivityLog(Profile* profile)
     : policy_(NULL),
       policy_type_(ActivityLogPolicy::POLICY_INVALID),
       profile_(profile),
       enabled_(false),
-      initialized_(false),
       policy_chosen_(false),
       testing_mode_(false),
       has_threads_(true),
-      tracker_(NULL) {
+      tracker_(NULL),
+      watchdog_extension_active_(false) {
   // This controls whether logging statements are printed, which policy is set,
   // etc.
   testing_mode_ = CommandLine::ForCurrentProcess()->HasSwitch(
     switches::kEnableExtensionActivityLogTesting);
 
+  // Check if the watchdog extension is previously installed and active.
+  watchdog_extension_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.
   if (!BrowserThread::IsMessageLoopValid(BrowserThread::DB) ||
       !BrowserThread::IsMessageLoopValid(BrowserThread::FILE) ||
       !BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
     LOG(ERROR) << "Missing threads, disabling Activity Logging!";
     has_threads_ = false;
-  } else {
-    enabled_ = IsLogEnabledOnAnyProfile();
-    ExtensionSystem::Get(profile_)->ready().Post(
-      FROM_HERE, base::Bind(&ActivityLog::Init, base::Unretained(this)));
   }
 
-  observers_ = new ObserverListThreadSafe<Observer>;
+  enabled_ = has_threads_
+      && (CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kEnableExtensionActivityLogging)
+      || watchdog_extension_active_);
+
+  if (enabled_) maybe_enabled_ = true;
+
+  ExtensionSystem::Get(profile_)->ready().Post(
+      FROM_HERE,
+      base::Bind(&ActivityLog::InitInstallTracker, base::Unretained(this)));
+  ChooseDefaultPolicy();
 }
 
-void ActivityLog::Init() {
-  DCHECK(has_threads_);
-  DCHECK(!initialized_);
-  const Extension* whitelisted_extension = ExtensionSystem::Get(profile_)->
-      extension_service()->GetExtensionById(kActivityLogExtensionId, false);
-  if (whitelisted_extension) {
-    enabled_ = true;
-    LogIsEnabled::GetInstance()->SetProfileEnabled(true);
-  }
+void ActivityLog::InitInstallTracker() {
   tracker_ = InstallTrackerFactory::GetForProfile(profile_);
   tracker_->AddObserver(this);
-  ChooseDefaultPolicy();
-  initialized_ = true;
 }
 
 void ActivityLog::ChooseDefaultPolicy() {
   if (policy_chosen_ || !enabled_) return;
   if (testing_mode_)
     SetDefaultPolicy(ActivityLogPolicy::POLICY_FULLSTREAM);
   else
     SetDefaultPolicy(ActivityLogPolicy::POLICY_NOARGS);
 }
 
 void ActivityLog::Shutdown() {
   if (tracker_) tracker_->RemoveObserver(this);
 }
 
 ActivityLog::~ActivityLog() {
   if (policy_)
     policy_->Close();
 }
 
+// static
+bool ActivityLog::maybe_enabled_ = false;
+
+// static
+bool ActivityLog::MaybeLogEnabled() {
+  return maybe_enabled_;
+}
+
 bool ActivityLog::IsLogEnabled() {
-  if (!has_threads_ || !initialized_) return false;
+  // Make sure we are not enabled when there are no threads.
+  DCHECK(has_threads_ || !enabled_);
   return enabled_;
 }
 
 void ActivityLog::OnExtensionLoaded(const Extension* extension) {
   if (extension->id() != kActivityLogExtensionId) return;
-  enabled_ = true;
-  LogIsEnabled::GetInstance()->SetProfileEnabled(true);
+  if (has_threads_) {
+    enabled_ = true;
+    maybe_enabled_ = true;
+  }
+  if (!watchdog_extension_active_) {
+    watchdog_extension_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;
+    profile_->GetPrefs()->SetBoolean(prefs::kWatchdogExtensionActive,
+                                     false);
+  }
 }
 
 // static
 ActivityLog* ActivityLog::GetInstance(Profile* profile) {
   return ActivityLogFactory::GetForProfile(profile);
 }
 
 void ActivityLog::AddObserver(ActivityLog::Observer* observer) {
   observers_->AddObserver(observer);
 }
@@ skipping 75 matching lines @@
       for (std::set<std::string>::const_iterator it2 = it->second.begin();
            it2 != it->second.end();
            ++it2) {
         action->mutable_args()->AppendString(*it2);
       }
       LogAction(action);
     }
   }
 }
 
+// static
+void ActivityLog::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterBooleanPref(
+      prefs::kWatchdogExtensionActive,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
 }  // namespace extensions