chrome/renderer/extensions/user_script_scheduler.cc

   1 // Copyright (c) 2012 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/renderer/extensions/user_script_scheduler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "chrome/common/extensions/extension_messages.h"
  11 #include "chrome/renderer/chrome_render_process_observer.h"
  12 #include "chrome/renderer/extensions/chrome_v8_context.h"
  13 #include "chrome/renderer/extensions/dispatcher.h"
  14 #include "chrome/renderer/extensions/dom_activity_logger.h"
  15 #include "chrome/renderer/extensions/extension_groups.h"
  16 #include "chrome/renderer/extensions/extension_helper.h"
  17 #include "chrome/renderer/extensions/user_script_slave.h"
  18 #include "content/public/renderer/render_view.h"
  19 #include "content/public/renderer/v8_value_converter.h"
  20 #include "extensions/common/error_utils.h"
  21 #include "extensions/common/manifest_constants.h"
  22 #include "extensions/common/permissions/permissions_data.h"
  23 #include "third_party/WebKit/public/platform/WebString.h"
  24 #include "third_party/WebKit/public/platform/WebVector.h"
  25 #include "third_party/WebKit/public/web/WebDocument.h"
  26 #include "third_party/WebKit/public/web/WebFrame.h"
  27 #include "third_party/WebKit/public/web/WebView.h"
  28 #include "v8/include/v8.h"
  29
  30 namespace {
  31 // The length of time to wait after the DOM is complete to try and run user
  32 // scripts.
  33 const int kUserScriptIdleTimeoutMs = 200;
  34 }
  35
  36 using blink::WebDocument;
  37 using blink::WebFrame;
  38 using blink::WebString;
  39 using blink::WebVector;
  40 using blink::WebView;
  41
  42 namespace extensions {
  43
  44 UserScriptScheduler::UserScriptScheduler(WebFrame* frame,
  45                                          Dispatcher* dispatcher)
  46     : weak_factory_(this),
  47       frame_(frame),
  48       current_location_(UserScript::UNDEFINED),
  49       has_run_idle_(false),
  50       dispatcher_(dispatcher) {
  51   for (int i = UserScript::UNDEFINED; i < UserScript::RUN_LOCATION_LAST; ++i) {
  52     pending_execution_map_[static_cast<UserScript::RunLocation>(i)] =
  53       std::queue<linked_ptr<ExtensionMsg_ExecuteCode_Params> >();
  54   }
  55 }
  56
  57 UserScriptScheduler::~UserScriptScheduler() {
  58 }
  59
  60 void UserScriptScheduler::ExecuteCode(
  61     const ExtensionMsg_ExecuteCode_Params& params) {
  62   UserScript::RunLocation run_at =
  63     static_cast<UserScript::RunLocation>(params.run_at);
  64   if (current_location_ < run_at) {
  65     pending_execution_map_[run_at].push(
  66         linked_ptr<ExtensionMsg_ExecuteCode_Params>(
  67             new ExtensionMsg_ExecuteCode_Params(params)));
  68     return;
  69   }
  70
  71   ExecuteCodeImpl(params);
  72 }
  73
  74 void UserScriptScheduler::DidCreateDocumentElement() {
  75   current_location_ = UserScript::DOCUMENT_START;
  76   MaybeRun();
  77 }
  78
  79 void UserScriptScheduler::DidFinishDocumentLoad() {
  80   current_location_ = UserScript::DOCUMENT_END;
  81   MaybeRun();
  82   // Schedule a run for DOCUMENT_IDLE
  83   base::MessageLoop::current()->PostDelayedTask(
  84       FROM_HERE,
  85       base::Bind(&UserScriptScheduler::IdleTimeout, weak_factory_.GetWeakPtr()),
  86       base::TimeDelta::FromMilliseconds(kUserScriptIdleTimeoutMs));
  87 }
  88
  89 void UserScriptScheduler::DidFinishLoad() {
  90   current_location_ = UserScript::DOCUMENT_IDLE;
  91   // Ensure that running scripts does not keep any progress UI running.
  92   base::MessageLoop::current()->PostTask(
  93       FROM_HERE,
  94       base::Bind(&UserScriptScheduler::MaybeRun, weak_factory_.GetWeakPtr()));
  95 }
  96
  97 void UserScriptScheduler::DidStartProvisionalLoad() {
  98   // The frame is navigating, so reset the state since we'll want to inject
  99   // scripts once the load finishes.
 100   current_location_ = UserScript::UNDEFINED;
 101   has_run_idle_ = false;
 102   weak_factory_.InvalidateWeakPtrs();
 103   std::map<UserScript::RunLocation, ExecutionQueue>::iterator itr =
 104     pending_execution_map_.begin();
 105   for (itr = pending_execution_map_.begin();
 106        itr != pending_execution_map_.end(); ++itr) {
 107     while (!itr->second.empty())
 108       itr->second.pop();
 109   }
 110 }
 111
 112 void UserScriptScheduler::IdleTimeout() {
 113   current_location_ = UserScript::DOCUMENT_IDLE;
 114   MaybeRun();
 115 }
 116
 117 void UserScriptScheduler::MaybeRun() {
 118   if (current_location_ == UserScript::UNDEFINED)
 119     return;
 120
 121   if (!has_run_idle_ && current_location_ == UserScript::DOCUMENT_IDLE) {
 122     has_run_idle_ = true;
 123     dispatcher_->user_script_slave()->InjectScripts(
 124         frame_, UserScript::DOCUMENT_IDLE);
 125   }
 126
 127   // Run all tasks from the current time and earlier.
 128   for (int i = UserScript::DOCUMENT_START;
 129        i <= current_location_; ++i) {
 130     UserScript::RunLocation run_time = static_cast<UserScript::RunLocation>(i);
 131     while (!pending_execution_map_[run_time].empty()) {
 132       linked_ptr<ExtensionMsg_ExecuteCode_Params>& params =
 133         pending_execution_map_[run_time].front();
 134       ExecuteCodeImpl(*params);
 135       pending_execution_map_[run_time].pop();
 136     }
 137   }
 138 }
 139
 140 void UserScriptScheduler::ExecuteCodeImpl(
 141     const ExtensionMsg_ExecuteCode_Params& params) {
 142   const Extension* extension = dispatcher_->extensions()->GetByID(
 143       params.extension_id);
 144   content::RenderView* render_view =
 145       content::RenderView::FromWebView(frame_->view());
 146   ExtensionHelper* extension_helper = ExtensionHelper::Get(render_view);
 147   base::ListValue execution_results;
 148
 149   // Since extension info is sent separately from user script info, they can
 150   // be out of sync. We just ignore this situation.
 151   if (!extension) {
 152     render_view->Send(
 153         new ExtensionHostMsg_ExecuteCodeFinished(render_view->GetRoutingID(),
 154                                                  params.request_id,
 155                                                  std::string(),  // no error
 156                                                  -1,
 157                                                  GURL(std::string()),
 158                                                  execution_results));
 159     return;
 160   }
 161
 162   std::vector<WebFrame*> frame_vector;
 163   frame_vector.push_back(frame_);
 164   if (params.all_frames)
 165     GetAllChildFrames(frame_, &frame_vector);
 166
 167   std::string error;
 168
 169   for (std::vector<WebFrame*>::iterator frame_it = frame_vector.begin();
 170        frame_it != frame_vector.end(); ++frame_it) {
 171     WebFrame* child_frame = *frame_it;
 172     if (params.is_javascript) {
 173       // We recheck access here in the renderer for extra safety against races
 174       // with navigation.
 175       //
 176       // But different frames can have different URLs, and the extension might
 177       // only have access to a subset of them. For the top frame, we can
 178       // immediately send an error and stop because the browser process
 179       // considers that an error too.
 180       //
 181       // For child frames, we just skip ones the extension doesn't have access
 182       // to and carry on.
 183       if (!params.is_web_view &&
 184           !PermissionsData::CanExecuteScriptOnPage(
 185               extension,
 186               child_frame->document().url(),
 187               frame_->document().url(),
 188               extension_helper->tab_id(),
 189               NULL,
 190               -1,
 191               NULL)) {
 192         if (child_frame->parent()) {
 193           continue;
 194         } else {
 195           error = ErrorUtils::FormatErrorMessage(
 196               manifest_errors::kCannotAccessPage,
 197               child_frame->document().url().spec());
 198           break;
 199         }
 200       }
 201
 202       WebScriptSource source(WebString::fromUTF8(params.code), params.file_url);
 203       v8::HandleScope scope(v8::Isolate::GetCurrent());
 204
 205       scoped_ptr<content::V8ValueConverter> v8_converter(
 206           content::V8ValueConverter::create());
 207       v8::Local<v8::Value> script_value;
 208
 209       if (params.in_main_world) {
 210         DOMActivityLogger::AttachToWorld(DOMActivityLogger::kMainWorldId,
 211                                          extension->id());
 212         script_value = child_frame->executeScriptAndReturnValue(source);
 213       } else {
 214         blink::WebVector<v8::Local<v8::Value> > results;
 215         std::vector<WebScriptSource> sources;
 216         sources.push_back(source);
 217         int isolated_world_id =
 218             dispatcher_->user_script_slave()->GetIsolatedWorldIdForExtension(
 219                 extension, child_frame);
 220         DOMActivityLogger::AttachToWorld(isolated_world_id, extension->id());
 221         child_frame->executeScriptInIsolatedWorld(
 222             isolated_world_id, &sources.front(),
 223             sources.size(), EXTENSION_GROUP_CONTENT_SCRIPTS, &results);
 224         // We only expect one value back since we only pushed one source
 225         if (results.size() == 1 && !results[0].IsEmpty())
 226           script_value = results[0];
 227       }
 228
 229       if (params.wants_result && !script_value.IsEmpty()) {
 230         // It's safe to always use the main world context when converting here.
 231         // V8ValueConverterImpl shouldn't actually care about the context scope,
 232         // and it switches to v8::Object's creation context when encountered.
 233         v8::Local<v8::Context> context = child_frame->mainWorldScriptContext();
 234         base::Value* result = v8_converter->FromV8Value(script_value, context);
 235         // Always append an execution result (i.e. no result == null result) so
 236         // that |execution_results| lines up with the frames.
 237         execution_results.Append(
 238             result ? result : base::Value::CreateNullValue());
 239       }
 240     } else {
 241       child_frame->document().insertUserStyleSheet(
 242           WebString::fromUTF8(params.code),
 243           // Author level is consistent with WebView::injectStyleSheet.
 244           WebDocument::UserStyleAuthorLevel);
 245     }
 246   }
 247
 248   render_view->Send(new ExtensionHostMsg_ExecuteCodeFinished(
 249       render_view->GetRoutingID(),
 250       params.request_id,
 251       error,
 252       render_view->GetPageId(),
 253       UserScriptSlave::GetDataSourceURLForFrame(frame_),
 254       execution_results));
 255 }
 256
 257 bool UserScriptScheduler::GetAllChildFrames(
 258     WebFrame* parent_frame,
 259     std::vector<WebFrame*>* frames_vector) const {
 260   if (!parent_frame)
 261     return false;
 262
 263   for (WebFrame* child_frame = parent_frame->firstChild(); child_frame;
 264        child_frame = child_frame->nextSibling()) {
 265     frames_vector->push_back(child_frame);
 266     GetAllChildFrames(child_frame, frames_vector);
 267   }
 268   return true;
 269 }
 270
 271 }  // namespace extensions