Sets correct ActivityLog enabled status to the first renderer process

chrome/browser/extensions/event_router.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/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 91 matching lines @@
                             FROM_HERE,
                             base::Bind(&LogExtensionEventMessage,
                                        profile_id,
                                        extension_id,
                                        event_name,
                                        base::Passed(&event_args)));
   } else {
     Profile* profile = reinterpret_cast<Profile*>(profile_id);
     if (!g_browser_process->profile_manager()->IsValidProfile(profile))
       return;
-    ActivityLog::GetInstance(profile)->LogEventAction(
+    ActivityLog* activity_log = ActivityLog::GetInstance(profile);
+    if (!activity_log->IsLogEnabled()) return;
+    activity_log->LogEventAction(
         extension_id, event_name, event_args.get(), std::string());
   }
 }
 
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* profile_id,
                                            const std::string& extension_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
-  if (ActivityLog::IsLogEnabledOnAnyProfile()) {

[felt, 2013/07/23 06:37:34]

Something I forgot about until now, and you should be aware of. This part is a
little tricky -- IsLogEnabledOnAnyProfile is, quite frankly, going to be wrong a
lot, so we 100% do want to get rid of it. However we can't switch to a
non-static method here because this method doesn't have a profile object. OTOH
it would be nice to not do this if the AL is disabled because dispatching the
IPC does have some cost.

The command line switch can be checked in a static method. Is there a way to
check prefs (perhaps all of the prefs) without using a profile object? If so we
could have a new, more-correct static method for here.

[pmarch, 2013/07/29 17:36:47]

Here, we need to check for command line switch and if the watchdog extension is
enabled. The command line switch can be checked statically but the watchdog
extension enable/disable status is per-profile. Thus we need to have a profile
object here.

I see two solutions:
1) implementing something similar to IsLogEnabledOnAnyProfile() 
2) moving message logging to the upper layer of IPC message handling where there
is a profile object available.

-    LogExtensionEventMessage(profile_id, extension_id, event_name,
-                             scoped_ptr<ListValue>(event_args->DeepCopy()));
-  }
+  LogExtensionEventMessage(profile_id, extension_id, event_name,
+                           scoped_ptr<ListValue>(event_args->DeepCopy()));
 
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
       MSG_ROUTING_CONTROL,
       extension_id,
       "event_bindings",
       "dispatchEvent",
@@ skipping 707 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions