Home | History | Annotate | Download | only in activity_log 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_ACTIONS_H_
      6 #define CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_ACTIONS_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/memory/ref_counted_memory.h"
     12 #include "base/time/time.h"
     13 #include "base/values.h"
     14 #include "chrome/browser/profiles/profile.h"
     15 #include "chrome/common/extensions/api/activity_log_private.h"
     16 #include "sql/connection.h"
     17 #include "sql/statement.h"
     18 #include "sql/transaction.h"
     19 #include "url/gurl.h"
     20 
     21 namespace extensions {
     22 
     23 // This is the interface for extension actions that are to be recorded in
     24 // the activity log.
     25 class Action : public base::RefCountedThreadSafe<Action> {
     26  public:
     27   // Types of log entries that can be stored.  The numeric values are stored in
     28   // the database, so keep them stable.  Append values only.
     29   enum ActionType {
     30     ACTION_API_CALL = 0,
     31     ACTION_API_EVENT = 1,
     32     UNUSED_ACTION_API_BLOCKED = 2,  // Not in use, but reserved for future.
     33     ACTION_CONTENT_SCRIPT = 3,
     34     ACTION_DOM_ACCESS = 4,
     35     ACTION_DOM_EVENT = 5,
     36     ACTION_WEB_REQUEST = 6,
     37     ACTION_ANY = 1001,              // Used for lookups of unspecified type.
     38   };
     39 
     40   // A useful shorthand for methods that take or return collections of Action
     41   // objects.
     42   typedef std::vector<scoped_refptr<Action> > ActionVector;
     43 
     44   // Creates a new activity log Action object.  The extension_id and type
     45   // fields are immutable.  All other fields can be filled in with the
     46   // accessors/mutators below.
     47   Action(const std::string& extension_id,
     48          const base::Time& time,
     49          const ActionType action_type,
     50          const std::string& api_name);
     51 
     52   // Creates and returns a mutable copy of an Action.
     53   scoped_refptr<Action> Clone() const;
     54 
     55   // The extension which caused this record to be generated.
     56   const std::string& extension_id() const { return extension_id_; }
     57 
     58   // The time the record was generated (or some approximation).
     59   const base::Time& time() const { return time_; }
     60   void set_time(const base::Time& time) { time_ = time; }
     61 
     62   // The ActionType distinguishes different classes of actions that can be
     63   // logged, and determines which other fields are expected to be filled in.
     64   ActionType action_type() const { return action_type_; }
     65 
     66   // The specific API call used or accessed, for example "chrome.tabs.get".
     67   const std::string& api_name() const { return api_name_; }
     68   void set_api_name(const std::string api_name) { api_name_ = api_name; }
     69 
     70   // Any applicable arguments.  This might be null to indicate no data
     71   // available (a distinct condition from an empty argument list).
     72   // mutable_args() returns a pointer to the list stored in the Action which
     73   // can be modified in place; if the list was null an empty list is created
     74   // first.
     75   const ListValue* args() const { return args_.get(); }
     76   void set_args(scoped_ptr<ListValue> args);
     77   ListValue* mutable_args();
     78 
     79   // The URL of the page which was modified or accessed.
     80   const GURL& page_url() const { return page_url_; }
     81   void set_page_url(const GURL& page_url);
     82 
     83   // The title of the above page if available.
     84   const std::string& page_title() const { return page_title_; }
     85   void set_page_title(const std::string& title) { page_title_ = title; }
     86 
     87   // A URL which appears in the arguments of the API call, if present.
     88   const GURL& arg_url() const { return arg_url_; }
     89   void set_arg_url(const GURL& arg_url);
     90 
     91   // Get or set a flag indicating whether the page or argument values above
     92   // refer to incognito pages.
     93   bool page_incognito() const { return page_incognito_; }
     94   void set_page_incognito(bool incognito) { page_incognito_ = incognito; }
     95   bool arg_incognito() const { return arg_incognito_; }
     96   void set_arg_incognito(bool incognito) { arg_incognito_ = incognito; }
     97 
     98   // A dictionary where any additional data can be stored.
     99   const DictionaryValue* other() const { return other_.get(); }
    100   void set_other(scoped_ptr<DictionaryValue> other);
    101   DictionaryValue* mutable_other();
    102 
    103   // Helper methods for serializing and deserializing URLs into strings.  If
    104   // the URL is marked as incognito, then the string is prefixed with
    105   // kIncognitoUrl ("<incognito>").
    106   std::string SerializePageUrl() const;
    107   void ParsePageUrl(const std::string& url);
    108   std::string SerializeArgUrl() const;
    109   void ParseArgUrl(const std::string& url);
    110 
    111   // Number of merged records for this action.
    112   int count() const { return count_; }
    113   void set_count(int count) { count_ = count; }
    114 
    115   // Flatten the activity's type-specific fields into an ExtensionActivity.
    116   scoped_ptr<api::activity_log_private::ExtensionActivity>
    117       ConvertToExtensionActivity();
    118 
    119   // Print an action as a regular string for debugging purposes.
    120   virtual std::string PrintForDebug() const;
    121 
    122  protected:
    123   virtual ~Action();
    124 
    125  private:
    126   friend class base::RefCountedThreadSafe<Action>;
    127 
    128   std::string extension_id_;
    129   base::Time time_;
    130   ActionType action_type_;
    131   std::string api_name_;
    132   scoped_ptr<ListValue> args_;
    133   GURL page_url_;
    134   std::string page_title_;
    135   bool page_incognito_;
    136   GURL arg_url_;
    137   bool arg_incognito_;
    138   scoped_ptr<DictionaryValue> other_;
    139   int count_;
    140 
    141   DISALLOW_COPY_AND_ASSIGN(Action);
    142 };
    143 
    144 // A comparator for Action class objects; this performs a lexicographic
    145 // comparison of the fields of the Action object (in an unspecfied order).
    146 // This can be used to use Action objects as keys in STL containers.
    147 struct ActionComparator {
    148   // Evaluates the comparison lhs < rhs.
    149   bool operator()(const scoped_refptr<Action>& lhs,
    150                   const scoped_refptr<Action>& rhs) const;
    151 };
    152 
    153 // Like ActionComparator, but ignores the time field in comparisons.
    154 struct ActionComparatorExcludingTime {
    155   // Evaluates the comparison lhs < rhs.
    156   bool operator()(const scoped_refptr<Action>& lhs,
    157                   const scoped_refptr<Action>& rhs) const;
    158 };
    159 
    160 }  // namespace extensions
    161 
    162 #endif  // CHROME_BROWSER_EXTENSIONS_ACTIVITY_LOG_ACTIVITY_ACTIONS_H_
    163