Home | History | Annotate | Download | only in activity_log 
      1 // Copyright (c) 2011 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 #include "chrome/browser/extensions/activity_log/activity_log.h"
      6 
      7 #include <set>
      8 #include <vector>
      9 
     10 #include "base/command_line.h"
     11 #include "base/json/json_string_value_serializer.h"
     12 #include "base/lazy_instance.h"
     13 #include "base/logging.h"
     14 #include "base/strings/string_util.h"
     15 #include "base/strings/utf_string_conversions.h"
     16 #include "base/threading/thread_checker.h"
     17 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
     18 #include "chrome/browser/extensions/activity_log/counting_policy.h"
     19 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
     20 #include "chrome/browser/extensions/activity_log/uma_policy.h"
     21 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
     22 #include "chrome/browser/extensions/extension_tab_util.h"
     23 #include "chrome/browser/prefs/pref_service_syncable.h"
     24 #include "chrome/browser/prerender/prerender_manager.h"
     25 #include "chrome/browser/prerender/prerender_manager_factory.h"
     26 #include "chrome/browser/profiles/profile.h"
     27 #include "chrome/browser/ui/browser.h"
     28 #include "chrome/common/chrome_constants.h"
     29 #include "chrome/common/chrome_switches.h"
     30 #include "chrome/common/pref_names.h"
     31 #include "content/public/browser/browser_thread.h"
     32 #include "content/public/browser/web_contents.h"
     33 #include "extensions/browser/extension_registry.h"
     34 #include "extensions/browser/extension_registry_factory.h"
     35 #include "extensions/browser/extension_system.h"
     36 #include "extensions/browser/extension_system_provider.h"
     37 #include "extensions/browser/extensions_browser_client.h"
     38 #include "extensions/common/extension.h"
     39 #include "extensions/common/one_shot_event.h"
     40 #include "third_party/re2/re2/re2.h"
     41 #include "url/gurl.h"
     42 
     43 namespace constants = activity_log_constants;
     44 
     45 namespace extensions {
     46 
     47 namespace {
     48 
     49 using constants::kArgUrlPlaceholder;
     50 using content::BrowserThread;
     51 
     52 // If DOM API methods start with this string, we flag them as being of type
     53 // DomActionType::XHR.
     54 const char kDomXhrPrefix[] = "XMLHttpRequest.";
     55 
     56 // Specifies a possible action to take to get an extracted URL in the ApiInfo
     57 // structure below.
     58 enum Transformation {
     59   NONE,
     60   DICT_LOOKUP,
     61   LOOKUP_TAB_ID,
     62 };
     63 
     64 // Information about specific Chrome and DOM APIs, such as which contain
     65 // arguments that should be extracted into the arg_url field of an Action.
     66 struct ApiInfo {
     67   // The lookup key consists of the action_type and api_name in the Action
     68   // object.
     69   Action::ActionType action_type;
     70   const char* api_name;
     71 
     72   // If non-negative, an index into args might contain a URL to be extracted
     73   // into arg_url.
     74   int arg_url_index;
     75 
     76   // A transformation to apply to the data found at index arg_url_index in the
     77   // argument list.
     78   //
     79   // If NONE, the data is expected to be a string which is treated as a URL.
     80   //
     81   // If LOOKUP_TAB_ID, the data is either an integer which is treated as a tab
     82   // ID and translated (in the context of a provided Profile), or a list of tab
     83   // IDs which are translated.
     84   //
     85   // If DICT_LOOKUP, the data is expected to be a dictionary, and
     86   // arg_url_dict_path is a path (list of keys delimited by ".") where a URL
     87   // string is to be found.
     88   Transformation arg_url_transform;
     89   const char* arg_url_dict_path;
     90 };
     91 
     92 static const ApiInfo kApiInfoTable[] = {
     93     // Tabs APIs that require tab ID translation
     94     {Action::ACTION_API_CALL, "tabs.connect", 0, LOOKUP_TAB_ID, NULL},
     95     {Action::ACTION_API_CALL, "tabs.detectLanguage", 0, LOOKUP_TAB_ID, NULL},
     96     {Action::ACTION_API_CALL, "tabs.duplicate", 0, LOOKUP_TAB_ID, NULL},
     97     {Action::ACTION_API_CALL, "tabs.executeScript", 0, LOOKUP_TAB_ID, NULL},
     98     {Action::ACTION_API_CALL, "tabs.get", 0, LOOKUP_TAB_ID, NULL},
     99     {Action::ACTION_API_CALL, "tabs.insertCSS", 0, LOOKUP_TAB_ID, NULL},
    100     {Action::ACTION_API_CALL, "tabs.move", 0, LOOKUP_TAB_ID, NULL},
    101     {Action::ACTION_API_CALL, "tabs.reload", 0, LOOKUP_TAB_ID, NULL},
    102     {Action::ACTION_API_CALL, "tabs.remove", 0, LOOKUP_TAB_ID, NULL},
    103     {Action::ACTION_API_CALL, "tabs.sendMessage", 0, LOOKUP_TAB_ID, NULL},
    104     {Action::ACTION_API_CALL, "tabs.update", 0, LOOKUP_TAB_ID, NULL},
    105     {Action::ACTION_API_EVENT, "tabs.onUpdated", 0, LOOKUP_TAB_ID, NULL},
    106     {Action::ACTION_API_EVENT, "tabs.onMoved", 0, LOOKUP_TAB_ID, NULL},
    107     {Action::ACTION_API_EVENT, "tabs.onDetached", 0, LOOKUP_TAB_ID, NULL},
    108     {Action::ACTION_API_EVENT, "tabs.onAttached", 0, LOOKUP_TAB_ID, NULL},
    109     {Action::ACTION_API_EVENT, "tabs.onRemoved", 0, LOOKUP_TAB_ID, NULL},
    110     {Action::ACTION_API_EVENT, "tabs.onReplaced", 0, LOOKUP_TAB_ID, NULL},
    111 
    112     // Other APIs that accept URLs as strings
    113     {Action::ACTION_API_CALL, "bookmarks.create", 0, DICT_LOOKUP, "url"},
    114     {Action::ACTION_API_CALL, "bookmarks.update", 1, DICT_LOOKUP, "url"},
    115     {Action::ACTION_API_CALL, "cookies.get", 0, DICT_LOOKUP, "url"},
    116     {Action::ACTION_API_CALL, "cookies.getAll", 0, DICT_LOOKUP, "url"},
    117     {Action::ACTION_API_CALL, "cookies.remove", 0, DICT_LOOKUP, "url"},
    118     {Action::ACTION_API_CALL, "cookies.set", 0, DICT_LOOKUP, "url"},
    119     {Action::ACTION_API_CALL, "downloads.download", 0, DICT_LOOKUP, "url"},
    120     {Action::ACTION_API_CALL, "history.addUrl", 0, DICT_LOOKUP, "url"},
    121     {Action::ACTION_API_CALL, "history.deleteUrl", 0, DICT_LOOKUP, "url"},
    122     {Action::ACTION_API_CALL, "history.getVisits", 0, DICT_LOOKUP, "url"},
    123     {Action::ACTION_API_CALL, "webstore.install", 0, NONE, NULL},
    124     {Action::ACTION_API_CALL, "windows.create", 0, DICT_LOOKUP, "url"},
    125     {Action::ACTION_DOM_ACCESS, "Document.location", 0, NONE, NULL},
    126     {Action::ACTION_DOM_ACCESS, "HTMLAnchorElement.href", 0, NONE, NULL},
    127     {Action::ACTION_DOM_ACCESS, "HTMLButtonElement.formAction", 0, NONE, NULL},
    128     {Action::ACTION_DOM_ACCESS, "HTMLEmbedElement.src", 0, NONE, NULL},
    129     {Action::ACTION_DOM_ACCESS, "HTMLFormElement.action", 0, NONE, NULL},
    130     {Action::ACTION_DOM_ACCESS, "HTMLFrameElement.src", 0, NONE, NULL},
    131     {Action::ACTION_DOM_ACCESS, "HTMLHtmlElement.manifest", 0, NONE, NULL},
    132     {Action::ACTION_DOM_ACCESS, "HTMLIFrameElement.src", 0, NONE, NULL},
    133     {Action::ACTION_DOM_ACCESS, "HTMLImageElement.longDesc", 0, NONE, NULL},
    134     {Action::ACTION_DOM_ACCESS, "HTMLImageElement.src", 0, NONE, NULL},
    135     {Action::ACTION_DOM_ACCESS, "HTMLImageElement.lowsrc", 0, NONE, NULL},
    136     {Action::ACTION_DOM_ACCESS, "HTMLInputElement.formAction", 0, NONE, NULL},
    137     {Action::ACTION_DOM_ACCESS, "HTMLInputElement.src", 0, NONE, NULL},
    138     {Action::ACTION_DOM_ACCESS, "HTMLLinkElement.href", 0, NONE, NULL},
    139     {Action::ACTION_DOM_ACCESS, "HTMLMediaElement.src", 0, NONE, NULL},
    140     {Action::ACTION_DOM_ACCESS, "HTMLMediaElement.currentSrc", 0, NONE, NULL},
    141     {Action::ACTION_DOM_ACCESS, "HTMLModElement.cite", 0, NONE, NULL},
    142     {Action::ACTION_DOM_ACCESS, "HTMLObjectElement.data", 0, NONE, NULL},
    143     {Action::ACTION_DOM_ACCESS, "HTMLQuoteElement.cite", 0, NONE, NULL},
    144     {Action::ACTION_DOM_ACCESS, "HTMLScriptElement.src", 0, NONE, NULL},
    145     {Action::ACTION_DOM_ACCESS, "HTMLSourceElement.src", 0, NONE, NULL},
    146     {Action::ACTION_DOM_ACCESS, "HTMLTrackElement.src", 0, NONE, NULL},
    147     {Action::ACTION_DOM_ACCESS, "HTMLVideoElement.poster", 0, NONE, NULL},
    148     {Action::ACTION_DOM_ACCESS, "Location.assign", 0, NONE, NULL},
    149     {Action::ACTION_DOM_ACCESS, "Location.replace", 0, NONE, NULL},
    150     {Action::ACTION_DOM_ACCESS, "Window.location", 0, NONE, NULL},
    151     {Action::ACTION_DOM_ACCESS, "XMLHttpRequest.open", 1, NONE, NULL}};
    152 
    153 // A singleton class which provides lookups into the kApiInfoTable data
    154 // structure.  It inserts all data into a map on first lookup.
    155 class ApiInfoDatabase {
    156  public:
    157   static ApiInfoDatabase* GetInstance() {
    158     return Singleton<ApiInfoDatabase>::get();
    159   }
    160 
    161   // Retrieves an ApiInfo record for the given Action type.  Returns either a
    162   // pointer to the record, or NULL if no such record was found.
    163   const ApiInfo* Lookup(Action::ActionType action_type,
    164                         const std::string& api_name) const {
    165     std::map<std::string, const ApiInfo*>::const_iterator i =
    166         api_database_.find(api_name);
    167     if (i == api_database_.end())
    168       return NULL;
    169     if (i->second->action_type != action_type)
    170       return NULL;
    171     return i->second;
    172   }
    173 
    174  private:
    175   ApiInfoDatabase() {
    176     for (size_t i = 0; i < arraysize(kApiInfoTable); i++) {
    177       const ApiInfo* info = &kApiInfoTable[i];
    178       api_database_[info->api_name] = info;
    179     }
    180   }
    181   virtual ~ApiInfoDatabase() {}
    182 
    183   // The map is keyed by API name only, since API names aren't be repeated
    184   // across multiple action types in kApiInfoTable.  However, the action type
    185   // should still be checked before returning a positive match.
    186   std::map<std::string, const ApiInfo*> api_database_;
    187 
    188   friend struct DefaultSingletonTraits<ApiInfoDatabase>;
    189   DISALLOW_COPY_AND_ASSIGN(ApiInfoDatabase);
    190 };
    191 
    192 // Gets the URL for a given tab ID.  Helper method for ExtractUrls.  Returns
    193 // true if able to perform the lookup.  The URL is stored to *url, and
    194 // *is_incognito is set to indicate whether the URL is for an incognito tab.
    195 bool GetUrlForTabId(int tab_id,
    196                     Profile* profile,
    197                     GURL* url,
    198                     bool* is_incognito) {
    199   content::WebContents* contents = NULL;
    200   Browser* browser = NULL;
    201   bool found = ExtensionTabUtil::GetTabById(
    202       tab_id,
    203       profile,
    204       true,  // Search incognito tabs, too.
    205       &browser,
    206       NULL,
    207       &contents,
    208       NULL);
    209 
    210   if (found) {
    211     *url = contents->GetURL();
    212     *is_incognito = browser->profile()->IsOffTheRecord();
    213     return true;
    214   } else {
    215     return false;
    216   }
    217 }
    218 
    219 // Resolves an argument URL relative to a base page URL.  If the page URL is
    220 // not valid, then only absolute argument URLs are supported.
    221 bool ResolveUrl(const GURL& base, const std::string& arg, GURL* arg_out) {
    222   if (base.is_valid())
    223     *arg_out = base.Resolve(arg);
    224   else
    225     *arg_out = GURL(arg);
    226 
    227   return arg_out->is_valid();
    228 }
    229 
    230 // Performs processing of the Action object to extract URLs from the argument
    231 // list and translate tab IDs to URLs, according to the API call metadata in
    232 // kApiInfoTable.  Mutates the Action object in place.  There is a small chance
    233 // that the tab id->URL translation could be wrong, if the tab has already been
    234 // navigated by the time of invocation.
    235 //
    236 // Any extracted URL is stored into the arg_url field of the action, and the
    237 // URL in the argument list is replaced with the marker value "<arg_url>".  For
    238 // APIs that take a list of tab IDs, extracts the first valid URL into arg_url
    239 // and overwrites the other tab IDs in the argument list with the translated
    240 // URL.
    241 void ExtractUrls(scoped_refptr<Action> action, Profile* profile) {
    242   const ApiInfo* api_info = ApiInfoDatabase::GetInstance()->Lookup(
    243       action->action_type(), action->api_name());
    244   if (api_info == NULL)
    245     return;
    246 
    247   int url_index = api_info->arg_url_index;
    248 
    249   if (!action->args() || url_index < 0 ||
    250       static_cast<size_t>(url_index) >= action->args()->GetSize())
    251     return;
    252 
    253   // Do not overwrite an existing arg_url value in the Action, so that callers
    254   // have the option of doing custom arg_url extraction.
    255   if (action->arg_url().is_valid())
    256     return;
    257 
    258   GURL arg_url;
    259   bool arg_incognito = action->page_incognito();
    260 
    261   switch (api_info->arg_url_transform) {
    262     case NONE: {
    263       // No translation needed; just extract the URL directly from a raw string
    264       // or from a dictionary.  Succeeds if we can find a string in the
    265       // argument list and that the string resolves to a valid URL.
    266       std::string url_string;
    267       if (action->args()->GetString(url_index, &url_string) &&
    268           ResolveUrl(action->page_url(), url_string, &arg_url)) {
    269         action->mutable_args()->Set(url_index,
    270                                     new base::StringValue(kArgUrlPlaceholder));
    271       }
    272       break;
    273     }
    274 
    275     case DICT_LOOKUP: {
    276       CHECK(api_info->arg_url_dict_path);
    277       // Look up the URL from a dictionary at the specified location.  Succeeds
    278       // if we can find a dictionary in the argument list, the dictionary
    279       // contains the specified key, and the corresponding value resolves to a
    280       // valid URL.
    281       base::DictionaryValue* dict = NULL;
    282       std::string url_string;
    283       if (action->mutable_args()->GetDictionary(url_index, &dict) &&
    284           dict->GetString(api_info->arg_url_dict_path, &url_string) &&
    285           ResolveUrl(action->page_url(), url_string, &arg_url)) {
    286         dict->SetString(api_info->arg_url_dict_path, kArgUrlPlaceholder);
    287       }
    288       break;
    289     }
    290 
    291     case LOOKUP_TAB_ID: {
    292       // Translation of tab IDs to URLs has been requested.  There are two
    293       // cases to consider: either a single integer or a list of integers (when
    294       // multiple tabs are manipulated).
    295       int tab_id;
    296       base::ListValue* tab_list = NULL;
    297       if (action->args()->GetInteger(url_index, &tab_id)) {
    298         // Single tab ID to translate.
    299         GetUrlForTabId(tab_id, profile, &arg_url, &arg_incognito);
    300         if (arg_url.is_valid()) {
    301           action->mutable_args()->Set(
    302               url_index, new base::StringValue(kArgUrlPlaceholder));
    303         }
    304       } else if (action->mutable_args()->GetList(url_index, &tab_list)) {
    305         // A list of possible IDs to translate.  Work through in reverse order
    306         // so the last one translated is left in arg_url.
    307         int extracted_index = -1;  // Which list item is copied to arg_url?
    308         for (int i = tab_list->GetSize() - 1; i >= 0; --i) {
    309           if (tab_list->GetInteger(i, &tab_id) &&
    310               GetUrlForTabId(tab_id, profile, &arg_url, &arg_incognito)) {
    311             if (!arg_incognito)
    312               tab_list->Set(i, new base::StringValue(arg_url.spec()));
    313             extracted_index = i;
    314           }
    315         }
    316         if (extracted_index >= 0) {
    317           tab_list->Set(
    318               extracted_index, new base::StringValue(kArgUrlPlaceholder));
    319         }
    320       }
    321       break;
    322     }
    323 
    324     default:
    325       NOTREACHED();
    326   }
    327 
    328   if (arg_url.is_valid()) {
    329     action->set_arg_incognito(arg_incognito);
    330     action->set_arg_url(arg_url);
    331   }
    332 }
    333 
    334 }  // namespace
    335 
    336 // SET THINGS UP. --------------------------------------------------------------
    337 
    338 static base::LazyInstance<BrowserContextKeyedAPIFactory<ActivityLog> >
    339     g_factory = LAZY_INSTANCE_INITIALIZER;
    340 
    341 BrowserContextKeyedAPIFactory<ActivityLog>* ActivityLog::GetFactoryInstance() {
    342   return g_factory.Pointer();
    343 }
    344 
    345 // static
    346 ActivityLog* ActivityLog::GetInstance(content::BrowserContext* context) {
    347   return ActivityLog::GetFactoryInstance()->Get(
    348       Profile::FromBrowserContext(context));
    349 }
    350 
    351 // Use GetInstance instead of directly creating an ActivityLog.
    352 ActivityLog::ActivityLog(content::BrowserContext* context)
    353     : database_policy_(NULL),
    354       database_policy_type_(ActivityLogPolicy::POLICY_INVALID),
    355       uma_policy_(NULL),
    356       profile_(Profile::FromBrowserContext(context)),
    357       db_enabled_(false),
    358       testing_mode_(false),
    359       has_threads_(true),
    360       extension_registry_observer_(this),
    361       watchdog_apps_active_(0) {
    362   // This controls whether logging statements are printed & which policy is set.
    363   testing_mode_ = CommandLine::ForCurrentProcess()->HasSwitch(
    364     switches::kEnableExtensionActivityLogTesting);
    365 
    366   // Check if the watchdog extension is previously installed and active.
    367   // It was originally a boolean, but we've had to move to an integer. Handle
    368   // the legacy case.
    369   // TODO(felt): In M34, remove the legacy code & old pref.
    370   if (profile_->GetPrefs()->GetBoolean(prefs::kWatchdogExtensionActiveOld))
    371     profile_->GetPrefs()->SetInteger(prefs::kWatchdogExtensionActive, 1);
    372   watchdog_apps_active_ =
    373       profile_->GetPrefs()->GetInteger(prefs::kWatchdogExtensionActive);
    374 
    375   observers_ = new ObserverListThreadSafe<Observer>;
    376 
    377   // Check that the right threads exist for logging to the database.
    378   // If not, we shouldn't try to do things that require them.
    379   if (!BrowserThread::IsMessageLoopValid(BrowserThread::DB) ||
    380       !BrowserThread::IsMessageLoopValid(BrowserThread::FILE) ||
    381       !BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
    382     has_threads_ = false;
    383   }
    384 
    385   db_enabled_ = has_threads_
    386       && (CommandLine::ForCurrentProcess()->
    387           HasSwitch(switches::kEnableExtensionActivityLogging)
    388       || watchdog_apps_active_);
    389 
    390   ExtensionSystem::Get(profile_)->ready().Post(
    391       FROM_HERE,
    392       base::Bind(&ActivityLog::StartObserving, base::Unretained(this)));
    393 
    394   if (!profile_->IsOffTheRecord())
    395     uma_policy_ = new UmaPolicy(profile_);
    396 
    397   ChooseDatabasePolicy();
    398 }
    399 
    400 void ActivityLog::SetDatabasePolicy(
    401     ActivityLogPolicy::PolicyType policy_type) {
    402   if (database_policy_type_ == policy_type)
    403     return;
    404   if (!IsDatabaseEnabled() && !IsWatchdogAppActive())
    405     return;
    406 
    407   // Deleting the old policy takes place asynchronously, on the database
    408   // thread.  Initializing a new policy below similarly happens
    409   // asynchronously.  Since the two operations are both queued for the
    410   // database, the queue ordering should ensure that the deletion completes
    411   // before database initialization occurs.
    412   //
    413   // However, changing policies at runtime is still not recommended, and
    414   // likely only should be done for unit tests.
    415   if (database_policy_)
    416     database_policy_->Close();
    417 
    418   switch (policy_type) {
    419     case ActivityLogPolicy::POLICY_FULLSTREAM:
    420       database_policy_ = new FullStreamUIPolicy(profile_);
    421       break;
    422     case ActivityLogPolicy::POLICY_COUNTS:
    423       database_policy_ = new CountingPolicy(profile_);
    424       break;
    425     default:
    426       NOTREACHED();
    427   }
    428   database_policy_->Init();
    429   database_policy_type_ = policy_type;
    430 }
    431 
    432 ActivityLog::~ActivityLog() {
    433   if (uma_policy_)
    434     uma_policy_->Close();
    435   if (database_policy_)
    436     database_policy_->Close();
    437 }
    438 
    439 // MAINTAIN STATUS. ------------------------------------------------------------
    440 
    441 void ActivityLog::StartObserving() {
    442   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
    443 }
    444 
    445 void ActivityLog::ChooseDatabasePolicy() {
    446   if (!(IsDatabaseEnabled() || IsWatchdogAppActive()))
    447     return;
    448   if (testing_mode_)
    449     SetDatabasePolicy(ActivityLogPolicy::POLICY_FULLSTREAM);
    450   else
    451     SetDatabasePolicy(ActivityLogPolicy::POLICY_COUNTS);
    452 }
    453 
    454 bool ActivityLog::IsDatabaseEnabled() {
    455   // Make sure we are not enabled when there are no threads.
    456   DCHECK(has_threads_ || !db_enabled_);
    457   return db_enabled_;
    458 }
    459 
    460 bool ActivityLog::IsWatchdogAppActive() {
    461   return (watchdog_apps_active_ > 0);
    462 }
    463 
    464 void ActivityLog::SetWatchdogAppActiveForTesting(bool active) {
    465   watchdog_apps_active_ = active ? 1 : 0;
    466 }
    467 
    468 void ActivityLog::OnExtensionLoaded(content::BrowserContext* browser_context,
    469                                     const Extension* extension) {
    470   if (!ActivityLogAPI::IsExtensionWhitelisted(extension->id())) return;
    471   if (has_threads_)
    472     db_enabled_ = true;
    473   watchdog_apps_active_++;
    474   profile_->GetPrefs()->SetInteger(prefs::kWatchdogExtensionActive,
    475                                    watchdog_apps_active_);
    476   if (watchdog_apps_active_ == 1)
    477     ChooseDatabasePolicy();
    478 }
    479 
    480 void ActivityLog::OnExtensionUnloaded(content::BrowserContext* browser_context,
    481                                       const Extension* extension,
    482                                       UnloadedExtensionInfo::Reason reason) {
    483   if (!ActivityLogAPI::IsExtensionWhitelisted(extension->id())) return;
    484   watchdog_apps_active_--;
    485   profile_->GetPrefs()->SetInteger(prefs::kWatchdogExtensionActive,
    486                                    watchdog_apps_active_);
    487   if (watchdog_apps_active_ == 0 &&
    488       !CommandLine::ForCurrentProcess()->HasSwitch(
    489           switches::kEnableExtensionActivityLogging)) {
    490     db_enabled_ = false;
    491   }
    492 }
    493 
    494 // OnExtensionUnloaded will also be called right before this.
    495 void ActivityLog::OnExtensionUninstalled(
    496     content::BrowserContext* browser_context,
    497     const Extension* extension,
    498     extensions::UninstallReason reason) {
    499   if (ActivityLogAPI::IsExtensionWhitelisted(extension->id()) &&
    500       !CommandLine::ForCurrentProcess()->HasSwitch(
    501           switches::kEnableExtensionActivityLogging) &&
    502       watchdog_apps_active_ == 0) {
    503     DeleteDatabase();
    504   } else if (database_policy_) {
    505     database_policy_->RemoveExtensionData(extension->id());
    506   }
    507 }
    508 
    509 void ActivityLog::AddObserver(ActivityLog::Observer* observer) {
    510   observers_->AddObserver(observer);
    511 }
    512 
    513 void ActivityLog::RemoveObserver(ActivityLog::Observer* observer) {
    514   observers_->RemoveObserver(observer);
    515 }
    516 
    517 // static
    518 void ActivityLog::RegisterProfilePrefs(
    519     user_prefs::PrefRegistrySyncable* registry) {
    520   registry->RegisterIntegerPref(
    521       prefs::kWatchdogExtensionActive,
    522       false,
    523       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    524   registry->RegisterBooleanPref(
    525       prefs::kWatchdogExtensionActiveOld,
    526       false,
    527       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    528 }
    529 
    530 // LOG ACTIONS. ----------------------------------------------------------------
    531 
    532 void ActivityLog::LogAction(scoped_refptr<Action> action) {
    533   if (ActivityLogAPI::IsExtensionWhitelisted(action->extension_id()))
    534     return;
    535 
    536   // Perform some preprocessing of the Action data: convert tab IDs to URLs and
    537   // mask out incognito URLs if appropriate.
    538   ExtractUrls(action, profile_);
    539 
    540   // Mark DOM XHR requests as such, for easier processing later.
    541   if (action->action_type() == Action::ACTION_DOM_ACCESS &&
    542       StartsWithASCII(action->api_name(), kDomXhrPrefix, true) &&
    543       action->other()) {
    544     base::DictionaryValue* other = action->mutable_other();
    545     int dom_verb = -1;
    546     if (other->GetInteger(constants::kActionDomVerb, &dom_verb) &&
    547         dom_verb == DomActionType::METHOD) {
    548       other->SetInteger(constants::kActionDomVerb, DomActionType::XHR);
    549     }
    550   }
    551 
    552   if (uma_policy_)
    553     uma_policy_->ProcessAction(action);
    554   if (IsDatabaseEnabled() && database_policy_)
    555     database_policy_->ProcessAction(action);
    556   if (IsWatchdogAppActive())
    557     observers_->Notify(&Observer::OnExtensionActivity, action);
    558   if (testing_mode_)
    559     VLOG(1) << action->PrintForDebug();
    560 }
    561 
    562 void ActivityLog::OnScriptsExecuted(
    563     const content::WebContents* web_contents,
    564     const ExecutingScriptsMap& extension_ids,
    565     const GURL& on_url) {
    566   Profile* profile =
    567       Profile::FromBrowserContext(web_contents->GetBrowserContext());
    568   ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
    569   for (ExecutingScriptsMap::const_iterator it = extension_ids.begin();
    570        it != extension_ids.end(); ++it) {
    571     const Extension* extension =
    572         registry->GetExtensionById(it->first, ExtensionRegistry::ENABLED);
    573     if (!extension || ActivityLogAPI::IsExtensionWhitelisted(extension->id()))
    574       continue;
    575 
    576     // If OnScriptsExecuted is fired because of tabs.executeScript, the list
    577     // of content scripts will be empty.  We don't want to log it because
    578     // the call to tabs.executeScript will have already been logged anyway.
    579     if (!it->second.empty()) {
    580       scoped_refptr<Action> action;
    581       action = new Action(extension->id(),
    582                           base::Time::Now(),
    583                           Action::ACTION_CONTENT_SCRIPT,
    584                           "");  // no API call here
    585       action->set_page_url(on_url);
    586       action->set_page_title(base::UTF16ToUTF8(web_contents->GetTitle()));
    587       action->set_page_incognito(
    588           web_contents->GetBrowserContext()->IsOffTheRecord());
    589 
    590       const prerender::PrerenderManager* prerender_manager =
    591           prerender::PrerenderManagerFactory::GetForProfile(profile);
    592       if (prerender_manager &&
    593           prerender_manager->IsWebContentsPrerendering(web_contents, NULL))
    594         action->mutable_other()->SetBoolean(constants::kActionPrerender, true);
    595       for (std::set<std::string>::const_iterator it2 = it->second.begin();
    596            it2 != it->second.end();
    597            ++it2) {
    598         action->mutable_args()->AppendString(*it2);
    599       }
    600       LogAction(action);
    601     }
    602   }
    603 }
    604 
    605 void ActivityLog::OnApiEventDispatched(const std::string& extension_id,
    606                                        const std::string& event_name,
    607                                        scoped_ptr<base::ListValue> event_args) {
    608   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    609   scoped_refptr<Action> action = new Action(extension_id,
    610                                             base::Time::Now(),
    611                                             Action::ACTION_API_EVENT,
    612                                             event_name);
    613   action->set_args(event_args.Pass());
    614   LogAction(action);
    615 }
    616 
    617 void ActivityLog::OnApiFunctionCalled(const std::string& extension_id,
    618                                       const std::string& api_name,
    619                                       scoped_ptr<base::ListValue> args) {
    620   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    621   scoped_refptr<Action> action = new Action(extension_id,
    622                                             base::Time::Now(),
    623                                             Action::ACTION_API_CALL,
    624                                             api_name);
    625   action->set_args(args.Pass());
    626   LogAction(action);
    627 }
    628 
    629 // LOOKUP ACTIONS. -------------------------------------------------------------
    630 
    631 void ActivityLog::GetFilteredActions(
    632     const std::string& extension_id,
    633     const Action::ActionType type,
    634     const std::string& api_name,
    635     const std::string& page_url,
    636     const std::string& arg_url,
    637     const int daysAgo,
    638     const base::Callback
    639         <void(scoped_ptr<std::vector<scoped_refptr<Action> > >)>& callback) {
    640   if (database_policy_) {
    641     database_policy_->ReadFilteredData(
    642         extension_id, type, api_name, page_url, arg_url, daysAgo, callback);
    643   }
    644 }
    645 
    646 // DELETE ACTIONS. -------------------------------------------------------------
    647 
    648 void ActivityLog::RemoveActions(const std::vector<int64>& action_ids) {
    649   if (!database_policy_)
    650     return;
    651   database_policy_->RemoveActions(action_ids);
    652 }
    653 
    654 void ActivityLog::RemoveURLs(const std::vector<GURL>& restrict_urls) {
    655   if (!database_policy_)
    656     return;
    657   database_policy_->RemoveURLs(restrict_urls);
    658 }
    659 
    660 void ActivityLog::RemoveURLs(const std::set<GURL>& restrict_urls) {
    661   if (!database_policy_)
    662     return;
    663 
    664   std::vector<GURL> urls;
    665   for (std::set<GURL>::const_iterator it = restrict_urls.begin();
    666        it != restrict_urls.end(); ++it) {
    667     urls.push_back(*it);
    668   }
    669   database_policy_->RemoveURLs(urls);
    670 }
    671 
    672 void ActivityLog::RemoveURL(const GURL& url) {
    673   if (url.is_empty())
    674     return;
    675   std::vector<GURL> urls;
    676   urls.push_back(url);
    677   RemoveURLs(urls);
    678 }
    679 
    680 void ActivityLog::DeleteDatabase() {
    681   if (!database_policy_)
    682     return;
    683   database_policy_->DeleteDatabase();
    684 }
    685 
    686 template <>
    687 void BrowserContextKeyedAPIFactory<ActivityLog>::DeclareFactoryDependencies() {
    688   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
    689   DependsOn(ExtensionRegistryFactory::GetInstance());
    690 }
    691 
    692 }  // namespace extensions
    693