Revert 203950 "Remove Activity Log usage of Extension objects"

trunk/src/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 20 matching lines @@
 using content::BrowserThread;
 
 namespace extensions {
 class Extension;
 
 // A utility for tracing interesting activity for each extension.
 // It writes to an ActivityDatabase on a separate thread to record the activity.
 class ActivityLog : public BrowserContextKeyedService,
                     public TabHelper::ScriptExecutionObserver {
  public:
+  enum Activity {
+    ACTIVITY_EXTENSION_API_CALL,   // Extension API invocation is called.
+    ACTIVITY_EXTENSION_API_BLOCK,  // Extension API invocation is blocked.
+    ACTIVITY_CONTENT_SCRIPT,       // Content script is executing.
+    ACTIVITY_EVENT_DISPATCH,       // Event sent to listener in extension.
+  };
+
   // Observers can listen for activity events.
   class Observer {
    public:
-    virtual void OnExtensionActivity(scoped_refptr<Action> activity) = 0;
+    virtual void OnExtensionActivity(
+        const Extension* extension,
+        Activity activity,
+        const std::string& message) = 0;
   };
 
   // ActivityLog is a singleton, so don't instantiate it with the constructor;
   // use GetInstance instead.
   static ActivityLog* GetInstance(Profile* profile);
 
   // 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(Observer* observer);
-  void RemoveObserver(Observer* observer);
+  void AddObserver(const Extension* extension, 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 std::string& extension_id,
+  void LogAPIAction(const Extension* extension,
                     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 std::string& extension_id,
+  void LogEventAction(const Extension* extension,
                       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 std::string& extension_id,
+  void LogBlockedAction(const Extension* extension,
                         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.
-  void LogDOMAction(const std::string& extension_id,
+  void LogDOMAction(const Extension* extension,
                     const GURL& url,                      // target URL
                     const string16& url_title,            // title of the URL
                     const std::string& api_call,          // api call
                     const ListValue* args,                // arguments
                     DomActionType::Type call_type,        // type of the call
                     const std::string& extra);            // extra logging info
 
   // Log a use of the WebRequest API to redirect, cancel, or modify page
   // headers.
-  void LogWebRequestAction(const std::string& extension_id,
+  void LogWebRequestAction(const Extension* extension,
                            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 10 matching lines @@
 
   explicit ActivityLog(Profile* profile);
   virtual ~ActivityLog();
 
   // Reset the database in case of persistent catastrophic errors.
   void DatabaseErrorCallback(int error, sql::Statement* stmt);
 
   // We log callbacks and API calls very similarly, so we handle them the same
   // way internally.
   void LogAPIActionInternal(
-      const std::string& extension_id,
+      const Extension* extension,
       const std::string& api_call,
       ListValue* args,
       const std::string& extra,
       const APIAction::Type type);
 
   // TabHelper::ScriptExecutionObserver implementation.
   // Fires when a ContentScript is executed.
   virtual void OnScriptsExecuted(
       const content::WebContents* web_contents,
       const ExecutingScriptsMap& extension_ids,
       int32 page_id,
       const GURL& on_url) OVERRIDE;
 
   // The callback when initializing the database.
   void OnDBInitComplete();
 
+  static const char* ActivityToString(Activity activity);
+
   // The Schedule methods dispatch the calls to the database on a
   // separate thread. We dispatch to the UI thread if the DB thread doesn't
   // exist, which should only happen in tests where there is no DB thread.
   template<typename DatabaseFunc>
   void ScheduleAndForget(DatabaseFunc func) {
     BrowserThread::PostTask(dispatch_thread_,
                             FROM_HERE,
                             base::Bind(func, base::Unretained(db_)));
   }
 
   template<typename DatabaseFunc, typename ArgA>
   void ScheduleAndForget(DatabaseFunc func, ArgA a) {
     BrowserThread::PostTask(dispatch_thread_,
                             FROM_HERE,
                             base::Bind(func, base::Unretained(db_), a));
   }
 
   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_