Remove Activity Log usage of Extension objects

chrome/browser/extensions/activity_log/activity_log.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_LOG_H_
 #define CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_LOG_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 49 matching lines @@
   // Currently, we only want to record actions if the user has opted in to the
   // ActivityLog feature.
   static bool IsLogEnabled();
 
   // Recompute whether logging should be enabled (the value of IsLogEnabled is
   // normally cached).  WARNING: This may not be thread-safe, and is only
   // really intended for use by unit tests.
   static void RecomputeLoggingIsEnabled();
 
   // Add/remove observer.
-  void AddObserver(const Extension* extension, Observer* observer);
+  void AddObserver(const Extension* extension,

[Matt Perry, 2013/05/29 18:01:17]

no need to wrap here. Ditto for RemoveObserver.

[felt, 2013/05/30 07:21:02]

Now that the other CL landed I can completely delete the Extension* object from
the signature, so issue incidentally solved.

On 2013/05/29 18:01:17, Matt Perry wrote:

+                   Observer* observer);
   void RemoveObserver(const Extension* extension,
                       Observer* observer);
 
-  // Check for the existence observer list by extension_id.
-  bool HasObservers(const Extension* extension) const;
-
   // Log a successful API call made by an extension.
   // This will create an APIAction for storage in the database.
   // (Note: implemented as a wrapper for LogAPIActionInternal.)
-  void LogAPIAction(const Extension* extension,
+  void LogAPIAction(const std::string& extension_id,
                     const std::string& name,    // e.g., tabs.get
                     ListValue* args,            // the argument values e.g. 46
                     const std::string& extra);  // any extra logging info
 
   // Log an event notification delivered to an extension.
   // This will create an APIAction for storage in the database.
   // (Note: implemented as a wrapper for LogAPIActionInternal.)
-  void LogEventAction(const Extension* extension,
+  void LogEventAction(const std::string& extension_id,
                       const std::string& name,    // e.g., tabs.onUpdate
                       ListValue* args,            // arguments to the callback
                       const std::string& extra);  // any extra logging info
 
   // Log a blocked API call made by an extension.
   // This will create a BlockedAction for storage in the database.
-  void LogBlockedAction(const Extension* extension,
+  void LogBlockedAction(const std::string& extension_id,
                         const std::string& blocked_call,  // e.g., tabs.get
                         ListValue* args,                  // argument values
                         const BlockedAction::Reason reason,  // why it's blocked
                         const std::string& extra);        // extra logging info
 
   // Log an interaction between an extension and a URL.
   // This will create a DOMAction for storage in the database.
   // The technical message might be the list of content scripts that have been
   // injected, or the DOM API call; it's what's shown under "More".
-  void LogDOMAction(const Extension* extension,
+  void LogDOMAction(const std::string& extension_id,
                     const GURL& url,                      // target URL
                     const string16& url_title,            // title of the URL
                     const std::string& api_call,          // api call
                     const ListValue* args,                // arguments
                     const std::string& extra);            // extra logging info
 
   // Log a use of the WebRequest API to redirect, cancel, or modify page
   // headers.
-  void LogWebRequestAction(const Extension* extension,
+  void LogWebRequestAction(const std::string& extension_id,
                            const GURL& url,
                            const std::string& api_call,
                            scoped_ptr<base::DictionaryValue> details,
                            const std::string& extra);
 
   // Retrieves the list of actions for a given extension on a specific day.
   // Today is 0, yesterday is 1, etc. Returns one day at a time.
   // Response is sent to the method/function in the callback.
   // Use base::Bind to create the callback.
   void GetActions(const std::string& extension_id,
@@ skipping 11 matching lines @@
 
  private:
   friend class ActivityLogFactory;
 
   explicit ActivityLog(Profile* profile);
   virtual ~ActivityLog();
 
   // We log callbacks and API calls very similarly, so we handle them the same
   // way internally.
   void LogAPIActionInternal(
-      const Extension* extension,
+      const std::string& extension_id,
       const std::string& api_call,
       ListValue* args,
       const std::string& extra,
       const APIAction::Type type);
 
   // We log content script injection and DOM API calls using the same underlying
   // mechanism, so they have the same internal logging structure.
-  void LogDOMActionInternal(const Extension* extension,
+  void LogDOMActionInternal(const std::string& extension_id,
                             const GURL& url,
                             const string16& url_title,
                             const std::string& api_call,
                             const ListValue* args,
                             const std::string& extra,
                             DOMAction::DOMActionType verb);
 
   // TabHelper::ScriptExecutionObserver implementation.
   // Fires when a ContentScript is executed.
   virtual void OnScriptsExecuted(
@@ skipping 25 matching lines @@
   }
 
   template<typename DatabaseFunc, typename ArgA, typename ArgB>
   void ScheduleAndForget(DatabaseFunc func, ArgA a, ArgB b) {
     BrowserThread::PostTask(dispatch_thread_,
                             FROM_HERE,
                             base::Bind(func, base::Unretained(db_), a, b));
   }
 
   typedef ObserverListThreadSafe<Observer> ObserverList;
-  typedef std::map<const Extension*, scoped_refptr<ObserverList> >
-      ObserverMap;
-  // A map of extensions to activity observers for that extension.
-  ObserverMap observers_;
 
   // The database wrapper that does the actual database I/O.
   // We initialize this on the same thread as the ActivityLog, but then
   // subsequent operations occur on the DB thread. Instead of destructing the
   // ActivityDatabase, we call its Close() method on the DB thread and it
   // commits suicide.
   extensions::ActivityDatabase* db_;
 
   // Normally the DB thread. In some cases (tests), it might not exist
   // we dispatch to the UI thread.
@@ skipping 40 matching lines @@
   virtual content::BrowserContext* GetBrowserContextToUse(
       content::BrowserContext* context) const OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(ActivityLogFactory);
 };
 
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_LOG_H_