extensions/renderer/dom_activity_logger.cc

   1 // Copyright 2014 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 "extensions/renderer/dom_activity_logger.h"
   6
   7 #include "content/public/renderer/render_thread.h"
   8 #include "content/public/renderer/v8_value_converter.h"
   9 #include "extensions/common/ad_injection_constants.h"
  10 #include "extensions/common/dom_action_types.h"
  11 #include "extensions/common/extension_messages.h"
  12 #include "extensions/renderer/activity_log_converter_strategy.h"
  13 #include "third_party/WebKit/public/platform/WebString.h"
  14 #include "third_party/WebKit/public/platform/WebURL.h"
  15
  16 using content::V8ValueConverter;
  17 using blink::WebString;
  18 using blink::WebURL;
  19
  20 namespace extensions {
  21
  22 namespace {
  23
  24 // Converts the given |v8_value| and appends it to the given |list|, if the
  25 // conversion succeeds.
  26 void AppendV8Value(const std::string& api_name,
  27                    const v8::Handle<v8::Value>& v8_value,
  28                    base::ListValue* list) {
  29   DCHECK(list);
  30   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
  31   ActivityLogConverterStrategy strategy;
  32   strategy.set_enable_detailed_parsing(
  33       ad_injection_constants::ApiCanInjectAds(api_name));
  34   converter->SetFunctionAllowed(true);
  35   converter->SetStrategy(&strategy);
  36   scoped_ptr<base::Value> value(converter->FromV8Value(
  37       v8_value, v8::Isolate::GetCurrent()->GetCurrentContext()));
  38
  39   if (value.get())
  40     list->Append(value.release());
  41 }
  42
  43 }  // namespace
  44
  45 DOMActivityLogger::DOMActivityLogger(const std::string& extension_id)
  46     : extension_id_(extension_id) {
  47 }
  48
  49 DOMActivityLogger::~DOMActivityLogger() {}
  50
  51 void DOMActivityLogger::AttachToWorld(int world_id,
  52                                       const std::string& extension_id) {
  53 #if defined(ENABLE_EXTENSIONS)
  54   // If there is no logger registered for world_id, construct a new logger
  55   // and register it with world_id.
  56   if (!blink::hasDOMActivityLogger(world_id)) {
  57     DOMActivityLogger* logger = new DOMActivityLogger(extension_id);
  58     blink::setDOMActivityLogger(world_id, logger);
  59   }
  60 #endif
  61 }
  62
  63 void DOMActivityLogger::logGetter(const WebString& api_name,
  64                                   const WebURL& url,
  65                                   const WebString& title) {
  66   SendDomActionMessage(api_name.utf8(),
  67                        url,
  68                        title,
  69                        DomActionType::GETTER,
  70                        scoped_ptr<base::ListValue>(new base::ListValue()));
  71 }
  72
  73 void DOMActivityLogger::logSetter(const WebString& api_name,
  74                                   const v8::Handle<v8::Value>& new_value,
  75                                   const WebURL& url,
  76                                   const WebString& title) {
  77   logSetter(api_name, new_value, v8::Handle<v8::Value>(), url, title);
  78 }
  79
  80 void DOMActivityLogger::logSetter(const WebString& api_name,
  81                                   const v8::Handle<v8::Value>& new_value,
  82                                   const v8::Handle<v8::Value>& old_value,
  83                                   const WebURL& url,
  84                                   const WebString& title) {
  85   scoped_ptr<base::ListValue> args(new base::ListValue);
  86   std::string api_name_utf8 = api_name.utf8();
  87   AppendV8Value(api_name_utf8, new_value, args.get());
  88   if (!old_value.IsEmpty())
  89     AppendV8Value(api_name_utf8, old_value, args.get());
  90   SendDomActionMessage(
  91       api_name_utf8, url, title, DomActionType::SETTER, args.Pass());
  92 }
  93
  94 void DOMActivityLogger::logMethod(const WebString& api_name,
  95                                   int argc,
  96                                   const v8::Handle<v8::Value>* argv,
  97                                   const WebURL& url,
  98                                   const WebString& title) {
  99   scoped_ptr<base::ListValue> args(new base::ListValue);
 100   std::string api_name_utf8 = api_name.utf8();
 101   for (int i = 0; i < argc; ++i)
 102     AppendV8Value(api_name_utf8, argv[i], args.get());
 103   SendDomActionMessage(
 104       api_name_utf8, url, title, DomActionType::METHOD, args.Pass());
 105 }
 106
 107 void DOMActivityLogger::SendDomActionMessage(const std::string& api_call,
 108                                              const GURL& url,
 109                                              const base::string16& url_title,
 110                                              DomActionType::Type call_type,
 111                                              scoped_ptr<base::ListValue> args) {
 112   ExtensionHostMsg_DOMAction_Params params;
 113   params.api_call = api_call;
 114   params.url = url;
 115   params.url_title = url_title;
 116   params.call_type = call_type;
 117   params.arguments.Swap(args.get());
 118   content::RenderThread::Get()->Send(
 119       new ExtensionHostMsg_AddDOMActionToActivityLog(extension_id_, params));
 120 }
 121
 122 }  // namespace extensions