src/chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc

   1 // Copyright 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 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/values.h"
  11 #include "chrome/browser/browser_process.h"
  12 #include "chrome/browser/extensions/event_router_forwarder.h"
  13 #include "chrome/browser/extensions/extension_service.h"
  14 #include "chrome/browser/extensions/extension_system.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/common/extensions/api/activity_log_private.h"
  17 #include "chrome/common/pref_names.h"
  18
  19 namespace extensions {
  20
  21 namespace activity_log_private = api::activity_log_private;
  22
  23 using api::activity_log_private::ActivityResultSet;
  24 using api::activity_log_private::ExtensionActivity;
  25 using api::activity_log_private::Filter;
  26
  27 const char kActivityLogExtensionId[] = "abjoigjokfeibfhiahiijggogladbmfm";
  28 const char kActivityLogTestExtensionId[] = "hhcnncjlpehbepkbgccanfpkneoejnpb";
  29 // TODO(mvrable): Delete kActivityLogObsoleteExtensionId after ensuring that it
  30 // is no longer in use.
  31 const char kActivityLogObsoleteExtensionId[] =
  32     "acldcpdepobcjbdanifkmfndkjoilgba";
  33
  34 static base::LazyInstance<ProfileKeyedAPIFactory<ActivityLogAPI> >
  35     g_factory = LAZY_INSTANCE_INITIALIZER;
  36
  37 // static
  38 ProfileKeyedAPIFactory<ActivityLogAPI>* ActivityLogAPI::GetFactoryInstance() {
  39   return &g_factory.Get();
  40 }
  41
  42 template<>
  43 void ProfileKeyedAPIFactory<ActivityLogAPI>::DeclareFactoryDependencies() {
  44   DependsOn(ExtensionSystemFactory::GetInstance());
  45   DependsOn(ActivityLogFactory::GetInstance());
  46 }
  47
  48 ActivityLogAPI::ActivityLogAPI(Profile* profile)
  49     : profile_(profile),
  50       initialized_(false) {
  51   if (!ExtensionSystem::Get(profile_)->event_router()) {  // Check for testing.
  52     DVLOG(1) << "ExtensionSystem event_router does not exist.";
  53     return;
  54   }
  55   activity_log_ = extensions::ActivityLog::GetInstance(profile_);
  56   DCHECK(activity_log_);
  57   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
  58       this, activity_log_private::OnExtensionActivity::kEventName);
  59   activity_log_->AddObserver(this);
  60   initialized_ = true;
  61 }
  62
  63 ActivityLogAPI::~ActivityLogAPI() {
  64 }
  65
  66 void ActivityLogAPI::Shutdown() {
  67   if (!initialized_) {  // Check for testing.
  68     DVLOG(1) << "ExtensionSystem event_router does not exist.";
  69     return;
  70   }
  71   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
  72   activity_log_->RemoveObserver(this);
  73 }
  74
  75 // static
  76 bool ActivityLogAPI::IsExtensionWhitelisted(const std::string& extension_id) {
  77   return (extension_id == kActivityLogExtensionId ||
  78           extension_id == kActivityLogTestExtensionId ||
  79           extension_id == kActivityLogObsoleteExtensionId);
  80 }
  81
  82 void ActivityLogAPI::OnListenerAdded(const EventListenerInfo& details) {
  83   // TODO(felt): Only observe activity_log_ events when we have a customer.
  84 }
  85
  86 void ActivityLogAPI::OnListenerRemoved(const EventListenerInfo& details) {
  87   // TODO(felt): Only observe activity_log_ events when we have a customer.
  88 }
  89
  90 void ActivityLogAPI::OnExtensionActivity(scoped_refptr<Action> activity) {
  91   scoped_ptr<base::ListValue> value(new base::ListValue());
  92   scoped_ptr<ExtensionActivity> activity_arg =
  93       activity->ConvertToExtensionActivity();
  94   value->Append(activity_arg->ToValue().release());
  95   scoped_ptr<Event> event(
  96       new Event(activity_log_private::OnExtensionActivity::kEventName,
  97           value.Pass()));
  98   event->restrict_to_profile = profile_;
  99   ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
 100 }
 101
 102 bool ActivityLogPrivateGetExtensionActivitiesFunction::RunImpl() {
 103   scoped_ptr<activity_log_private::GetExtensionActivities::Params> params(
 104       activity_log_private::GetExtensionActivities::Params::Create(*args_));
 105   EXTENSION_FUNCTION_VALIDATE(params.get());
 106
 107   // Get the arguments in the right format.
 108   scoped_ptr<Filter> filter;
 109   filter.reset(&params.release()->filter);
 110   Action::ActionType action_type = Action::ACTION_API_CALL;
 111   switch (filter->activity_type) {
 112     case Filter::ACTIVITY_TYPE_API_CALL:
 113       action_type = Action::ACTION_API_CALL;
 114       break;
 115     case Filter::ACTIVITY_TYPE_API_EVENT:
 116       action_type = Action::ACTION_API_EVENT;
 117       break;
 118     case Filter::ACTIVITY_TYPE_CONTENT_SCRIPT:
 119       action_type = Action::ACTION_CONTENT_SCRIPT;
 120       break;
 121     case Filter::ACTIVITY_TYPE_DOM_ACCESS:
 122       action_type = Action::ACTION_DOM_ACCESS;
 123       break;
 124     case Filter::ACTIVITY_TYPE_DOM_EVENT:
 125       action_type = Action::ACTION_DOM_EVENT;
 126       break;
 127     case  Filter::ACTIVITY_TYPE_WEB_REQUEST:
 128       action_type = Action::ACTION_WEB_REQUEST;
 129       break;
 130     case Filter::ACTIVITY_TYPE_ANY:
 131     default:
 132       action_type = Action::ACTION_ANY;
 133   }
 134   std::string extension_id =
 135       filter->extension_id.get() ? *filter->extension_id : std::string();
 136   std::string api_call =
 137       filter->api_call.get() ? *filter->api_call : std::string();
 138   std::string page_url =
 139       filter->page_url.get() ? *filter->page_url : std::string();
 140   std::string arg_url =
 141       filter->arg_url.get() ? *filter->arg_url : std::string();
 142   int days_ago = -1;
 143   if (filter->days_ago.get())
 144     days_ago = *filter->days_ago;
 145
 146   // Call the ActivityLog.
 147   ActivityLog* activity_log = ActivityLog::GetInstance(GetProfile());
 148   DCHECK(activity_log);
 149   activity_log->GetFilteredActions(
 150       extension_id,
 151       action_type,
 152       api_call,
 153       page_url,
 154       arg_url,
 155       days_ago,
 156       base::Bind(
 157           &ActivityLogPrivateGetExtensionActivitiesFunction::OnLookupCompleted,
 158           this));
 159
 160   return true;
 161 }
 162
 163 void ActivityLogPrivateGetExtensionActivitiesFunction::OnLookupCompleted(
 164     scoped_ptr<std::vector<scoped_refptr<Action> > > activities) {
 165   // Convert Actions to ExtensionActivities.
 166   std::vector<linked_ptr<ExtensionActivity> > result_arr;
 167   for (std::vector<scoped_refptr<Action> >::iterator it = activities->begin();
 168        it != activities->end();
 169        ++it) {
 170     result_arr.push_back(
 171         make_linked_ptr(it->get()->ConvertToExtensionActivity().release()));
 172   }
 173
 174   // Populate the return object.
 175   scoped_ptr<ActivityResultSet> result_set(new ActivityResultSet);
 176   result_set->activities = result_arr;
 177   results_ = activity_log_private::GetExtensionActivities::Results::Create(
 178       *result_set);
 179
 180   SendResponse(true);
 181 }
 182
 183 bool ActivityLogPrivateDeleteDatabaseFunction::RunImpl() {
 184   ActivityLog* activity_log = ActivityLog::GetInstance(GetProfile());
 185   DCHECK(activity_log);
 186   activity_log->DeleteDatabase();
 187   return true;
 188 }
 189
 190 bool ActivityLogPrivateDeleteUrlsFunction::RunImpl() {
 191   scoped_ptr<activity_log_private::DeleteUrls::Params> params(
 192       activity_log_private::DeleteUrls::Params::Create(*args_));
 193   EXTENSION_FUNCTION_VALIDATE(params.get());
 194
 195   // Put the arguments in the right format.
 196   std::vector<GURL> gurls;
 197   std::vector<std::string> urls = *params->urls.get();
 198   for (std::vector<std::string>::iterator it = urls.begin();
 199        it != urls.end();
 200        ++it) {
 201     gurls.push_back(GURL(*it));
 202   }
 203
 204   ActivityLog* activity_log = ActivityLog::GetInstance(GetProfile());
 205   DCHECK(activity_log);
 206   activity_log->RemoveURLs(gurls);
 207   return true;
 208 }
 209
 210 }  // namespace extensions