extensions/renderer/script_injection_manager.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/script_injection_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/weak_ptr.h"
   9 #include "base/values.h"
  10 #include "content/public/renderer/render_view.h"
  11 #include "content/public/renderer/render_view_observer.h"
  12 #include "extensions/common/extension.h"
  13 #include "extensions/common/extension_messages.h"
  14 #include "extensions/common/extension_set.h"
  15 #include "extensions/renderer/extension_helper.h"
  16 #include "extensions/renderer/programmatic_script_injector.h"
  17 #include "extensions/renderer/script_injection.h"
  18 #include "extensions/renderer/scripts_run_info.h"
  19 #include "ipc/ipc_message_macros.h"
  20 #include "third_party/WebKit/public/web/WebDocument.h"
  21 #include "third_party/WebKit/public/web/WebFrame.h"
  22 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  23 #include "third_party/WebKit/public/web/WebView.h"
  24 #include "url/gurl.h"
  25
  26 namespace extensions {
  27
  28 namespace {
  29
  30 // The length of time to wait after the DOM is complete to try and run user
  31 // scripts.
  32 const int kScriptIdleTimeoutInMs = 200;
  33
  34 }  // namespace
  35
  36 class ScriptInjectionManager::RVOHelper : public content::RenderViewObserver {
  37  public:
  38   RVOHelper(content::RenderView* render_view, ScriptInjectionManager* manager);
  39   virtual ~RVOHelper();
  40
  41  private:
  42   // RenderViewObserver implementation.
  43   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  44   virtual void DidCreateDocumentElement(blink::WebLocalFrame* frame) OVERRIDE;
  45   virtual void DidFinishDocumentLoad(blink::WebLocalFrame* frame) OVERRIDE;
  46   virtual void DidFinishLoad(blink::WebLocalFrame* frame) OVERRIDE;
  47   virtual void DidStartProvisionalLoad(blink::WebLocalFrame* frame) OVERRIDE;
  48   virtual void FrameDetached(blink::WebFrame* frame) OVERRIDE;
  49   virtual void OnDestruct() OVERRIDE;
  50
  51   virtual void OnExecuteCode(const ExtensionMsg_ExecuteCode_Params& params);
  52   virtual void OnExecuteDeclarativeScript(int tab_id,
  53                                           const ExtensionId& extension_id,
  54                                           int script_id,
  55                                           const GURL& url);
  56   virtual void OnPermitScriptInjection(int64 request_id);
  57
  58   // Tells the ScriptInjectionManager to run tasks associated with
  59   // document_idle.
  60   void RunIdle(blink::WebFrame* frame);
  61
  62   // Indicate that the given |frame| is no longer valid because it is starting
  63   // a new load or closing.
  64   void InvalidateFrame(blink::WebFrame* frame);
  65
  66   // The owning ScriptInjectionManager.
  67   ScriptInjectionManager* manager_;
  68
  69   // The set of frames that we are about to notify for DOCUMENT_IDLE. We keep
  70   // a set of those that are valid, so we don't notify that an invalid frame
  71   // became idle.
  72   std::set<blink::WebFrame*> pending_idle_frames_;
  73
  74   base::WeakPtrFactory<RVOHelper> weak_factory_;
  75 };
  76
  77 ScriptInjectionManager::RVOHelper::RVOHelper(
  78     content::RenderView* render_view,
  79     ScriptInjectionManager* manager)
  80     : content::RenderViewObserver(render_view),
  81       manager_(manager),
  82       weak_factory_(this) {
  83 }
  84
  85 ScriptInjectionManager::RVOHelper::~RVOHelper() {
  86 }
  87
  88 bool ScriptInjectionManager::RVOHelper::OnMessageReceived(
  89     const IPC::Message& message) {
  90   bool handled = true;
  91   IPC_BEGIN_MESSAGE_MAP(ScriptInjectionManager::RVOHelper, message)
  92     IPC_MESSAGE_HANDLER(ExtensionMsg_ExecuteCode, OnExecuteCode)
  93     IPC_MESSAGE_HANDLER(ExtensionMsg_PermitScriptInjection,
  94                         OnPermitScriptInjection)
  95     IPC_MESSAGE_HANDLER(ExtensionMsg_ExecuteDeclarativeScript,
  96                         OnExecuteDeclarativeScript)
  97     IPC_MESSAGE_UNHANDLED(handled = false)
  98   IPC_END_MESSAGE_MAP()
  99   return handled;
 100 }
 101
 102 void ScriptInjectionManager::RVOHelper::DidCreateDocumentElement(
 103     blink::WebLocalFrame* frame) {
 104   manager_->InjectScripts(frame, UserScript::DOCUMENT_START);
 105 }
 106
 107 void ScriptInjectionManager::RVOHelper::DidFinishDocumentLoad(
 108     blink::WebLocalFrame* frame) {
 109   manager_->InjectScripts(frame, UserScript::DOCUMENT_END);
 110   pending_idle_frames_.insert(frame);
 111   // We try to run idle in two places: here and DidFinishLoad.
 112   // DidFinishDocumentLoad() corresponds to completing the document's load,
 113   // whereas DidFinishLoad corresponds to completing the document and all
 114   // subresources' load. We don't want to hold up script injection for a
 115   // particularly slow subresource, so we set a delayed task from here - but if
 116   // we finish everything before that point (i.e., DidFinishLoad() is
 117   // triggered), then there's no reason to keep waiting.
 118   base::MessageLoop::current()->PostDelayedTask(
 119       FROM_HERE,
 120       base::Bind(&ScriptInjectionManager::RVOHelper::RunIdle,
 121                  weak_factory_.GetWeakPtr(),
 122                  frame),
 123       base::TimeDelta::FromMilliseconds(kScriptIdleTimeoutInMs));
 124 }
 125
 126 void ScriptInjectionManager::RVOHelper::DidFinishLoad(
 127     blink::WebLocalFrame* frame) {
 128   // Ensure that we don't block any UI progress by running scripts.
 129   // We *don't* add the frame to |pending_idle_frames_| here because
 130   // DidFinishDocumentLoad should strictly come before DidFinishLoad, so the
 131   // first posted task to RunIdle() pops it out of the set. This ensures we
 132   // don't try to run idle twice.
 133   base::MessageLoop::current()->PostTask(
 134       FROM_HERE,
 135       base::Bind(&ScriptInjectionManager::RVOHelper::RunIdle,
 136                  weak_factory_.GetWeakPtr(),
 137                  frame));
 138 }
 139
 140 void ScriptInjectionManager::RVOHelper::DidStartProvisionalLoad(
 141     blink::WebLocalFrame* frame) {
 142   // We're starting a new load - invalidate.
 143   InvalidateFrame(frame);
 144 }
 145
 146 void ScriptInjectionManager::RVOHelper::FrameDetached(blink::WebFrame* frame) {
 147   // The frame is closing - invalidate.
 148   InvalidateFrame(frame);
 149 }
 150
 151 void ScriptInjectionManager::RVOHelper::OnDestruct() {
 152   manager_->RemoveObserver(this);
 153 }
 154
 155 void ScriptInjectionManager::RVOHelper::OnExecuteCode(
 156     const ExtensionMsg_ExecuteCode_Params& params) {
 157   manager_->HandleExecuteCode(params, render_view());
 158 }
 159
 160 void ScriptInjectionManager::RVOHelper::OnExecuteDeclarativeScript(
 161     int tab_id,
 162     const ExtensionId& extension_id,
 163     int script_id,
 164     const GURL& url) {
 165   blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
 166   CHECK(main_frame);
 167
 168   // TODO(markdittmer): This would be cleaner if we compared page_ids instead.
 169   // Begin script injeciton workflow only if the current URL is identical to
 170   // the one that matched declarative conditions in the browser.
 171   if (main_frame->top()->document().url() == url) {
 172     manager_->HandleExecuteDeclarativeScript(main_frame,
 173                                              tab_id,
 174                                              extension_id,
 175                                              script_id,
 176                                              url);
 177   }
 178 }
 179
 180 void ScriptInjectionManager::RVOHelper::OnPermitScriptInjection(
 181     int64 request_id) {
 182   manager_->HandlePermitScriptInjection(request_id);
 183 }
 184
 185 void ScriptInjectionManager::RVOHelper::RunIdle(blink::WebFrame* frame) {
 186   // Only notify the manager if the frame hasn't either been removed or already
 187   // had idle run since the task to RunIdle() was posted.
 188   if (pending_idle_frames_.count(frame) > 0) {
 189     manager_->InjectScripts(frame, UserScript::DOCUMENT_IDLE);
 190     pending_idle_frames_.erase(frame);
 191   }
 192 }
 193
 194 void ScriptInjectionManager::RVOHelper::InvalidateFrame(
 195     blink::WebFrame* frame) {
 196   pending_idle_frames_.erase(frame);
 197   manager_->InvalidateForFrame(frame);
 198 }
 199
 200 ScriptInjectionManager::ScriptInjectionManager(
 201     const ExtensionSet* extensions,
 202     UserScriptSetManager* user_script_set_manager)
 203     : extensions_(extensions),
 204       user_script_set_manager_(user_script_set_manager),
 205       user_script_set_manager_observer_(this) {
 206   user_script_set_manager_observer_.Add(user_script_set_manager_);
 207 }
 208
 209 ScriptInjectionManager::~ScriptInjectionManager() {
 210 }
 211
 212 void ScriptInjectionManager::OnRenderViewCreated(
 213     content::RenderView* render_view) {
 214   rvo_helpers_.push_back(new RVOHelper(render_view, this));
 215 }
 216
 217 void ScriptInjectionManager::OnUserScriptsUpdated(
 218     const std::set<std::string>& changed_extensions,
 219     const std::vector<UserScript*>& scripts) {
 220   for (ScopedVector<ScriptInjection>::iterator iter =
 221            pending_injections_.begin();
 222        iter != pending_injections_.end();) {
 223     if (changed_extensions.count((*iter)->extension_id()) > 0)
 224       iter = pending_injections_.erase(iter);
 225     else
 226       ++iter;
 227   }
 228 }
 229
 230 void ScriptInjectionManager::RemoveObserver(RVOHelper* helper) {
 231   for (ScopedVector<RVOHelper>::iterator iter = rvo_helpers_.begin();
 232        iter != rvo_helpers_.end();
 233        ++iter) {
 234     if (*iter == helper) {
 235       rvo_helpers_.erase(iter);
 236       break;
 237     }
 238   }
 239 }
 240
 241 void ScriptInjectionManager::InvalidateForFrame(blink::WebFrame* frame) {
 242   for (ScopedVector<ScriptInjection>::iterator iter =
 243            pending_injections_.begin();
 244        iter != pending_injections_.end();) {
 245     if ((*iter)->web_frame() == frame)
 246       iter = pending_injections_.erase(iter);
 247     else
 248       ++iter;
 249   }
 250
 251   frame_statuses_.erase(frame);
 252 }
 253
 254 void ScriptInjectionManager::InjectScripts(
 255     blink::WebFrame* frame, UserScript::RunLocation run_location) {
 256   FrameStatusMap::iterator iter = frame_statuses_.find(frame);
 257   // We also don't execute if we detect that the run location is somehow out of
 258   // order. This can happen if:
 259   // - The first run location reported for the frame isn't DOCUMENT_START, or
 260   // - The run location reported doesn't immediately follow the previous
 261   //   reported run location.
 262   // We don't want to run because extensions may have requirements that scripts
 263   // running in an earlier run location have run by the time a later script
 264   // runs. Better to just not run.
 265   if ((iter == frame_statuses_.end() &&
 266            run_location != UserScript::DOCUMENT_START) ||
 267       (iter != frame_statuses_.end() && run_location - iter->second > 1)) {
 268     // We also invalidate the frame, because the run order of pending injections
 269     // may also be bad.
 270     InvalidateForFrame(frame);
 271     return;
 272   } else if (iter != frame_statuses_.end() && iter->second > run_location) {
 273     // Certain run location signals (like DidCreateDocumentElement) can happen
 274     // multiple times. Ignore the subsequent signals.
 275     return;
 276   }
 277
 278   // Otherwise, all is right in the world, and we can get on with the
 279   // injections!
 280
 281   frame_statuses_[frame] = run_location;
 282
 283   // Inject any scripts that were waiting for the right run location.
 284   ScriptsRunInfo scripts_run_info;
 285   for (ScopedVector<ScriptInjection>::iterator iter =
 286            pending_injections_.begin();
 287        iter != pending_injections_.end();) {
 288     if ((*iter)->web_frame() == frame &&
 289         (*iter)->TryToInject(run_location,
 290                              extensions_->GetByID((*iter)->extension_id()),
 291                              &scripts_run_info)) {
 292       iter = pending_injections_.erase(iter);
 293     } else {
 294       ++iter;
 295     }
 296   }
 297
 298   // Try to inject any user scripts that should run for this location. If they
 299   // don't complete their injection (for example, waiting for a permission
 300   // response) then they will be added to |pending_injections_|.
 301   ScopedVector<ScriptInjection> user_script_injections;
 302   int tab_id = ExtensionHelper::Get(content::RenderView::FromWebView(
 303                                         frame->top()->view()))->tab_id();
 304   user_script_set_manager_->GetAllInjections(
 305       &user_script_injections, frame, tab_id, run_location);
 306   for (ScopedVector<ScriptInjection>::iterator iter =
 307            user_script_injections.begin();
 308        iter != user_script_injections.end();) {
 309     scoped_ptr<ScriptInjection> injection(*iter);
 310     iter = user_script_injections.weak_erase(iter);
 311     if (!injection->TryToInject(run_location,
 312                                 extensions_->GetByID(injection->extension_id()),
 313                                 &scripts_run_info)) {
 314       pending_injections_.push_back(injection.release());
 315     }
 316   }
 317
 318   scripts_run_info.LogRun(frame, run_location);
 319 }
 320
 321 void ScriptInjectionManager::HandleExecuteCode(
 322     const ExtensionMsg_ExecuteCode_Params& params,
 323     content::RenderView* render_view) {
 324   // TODO(dcheng): Not sure how this can happen today. In an OOPI world, it
 325   // would indicate a logic error--the browser must direct this request to the
 326   // right renderer process to begin with.
 327   blink::WebLocalFrame* main_frame =
 328       render_view->GetWebView()->mainFrame()->toWebLocalFrame();
 329   if (!main_frame) {
 330     render_view->Send(
 331         new ExtensionHostMsg_ExecuteCodeFinished(render_view->GetRoutingID(),
 332                                                  params.request_id,
 333                                                  "No main frame",
 334                                                  GURL(std::string()),
 335                                                  base::ListValue()));
 336     return;
 337   }
 338
 339   scoped_ptr<ScriptInjection> injection(new ScriptInjection(
 340       scoped_ptr<ScriptInjector>(
 341           new ProgrammaticScriptInjector(params, main_frame)),
 342       main_frame,
 343       params.extension_id,
 344       static_cast<UserScript::RunLocation>(params.run_at),
 345       ExtensionHelper::Get(render_view)->tab_id()));
 346
 347   ScriptsRunInfo scripts_run_info;
 348   FrameStatusMap::const_iterator iter = frame_statuses_.find(main_frame);
 349   if (!injection->TryToInject(
 350           iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second,
 351           extensions_->GetByID(injection->extension_id()),
 352           &scripts_run_info)) {
 353     pending_injections_.push_back(injection.release());
 354   }
 355 }
 356
 357 void ScriptInjectionManager::HandleExecuteDeclarativeScript(
 358     blink::WebFrame* web_frame,
 359     int tab_id,
 360     const ExtensionId& extension_id,
 361     int script_id,
 362     const GURL& url) {
 363   const Extension* extension = extensions_->GetByID(extension_id);
 364   // TODO(dcheng): This function signature should really be a WebLocalFrame,
 365   // rather than trying to coerce it here.
 366   scoped_ptr<ScriptInjection> injection =
 367       user_script_set_manager_->GetInjectionForDeclarativeScript(
 368           script_id,
 369           web_frame->toWebLocalFrame(),
 370           tab_id,
 371           url,
 372           extension);
 373   if (injection.get()) {
 374     ScriptsRunInfo scripts_run_info;
 375     // TODO(markdittmer): Use return value of TryToInject for error handling.
 376     injection->TryToInject(UserScript::BROWSER_DRIVEN,
 377                            extension,
 378                            &scripts_run_info);
 379     scripts_run_info.LogRun(web_frame, UserScript::BROWSER_DRIVEN);
 380   }
 381 }
 382
 383 void ScriptInjectionManager::HandlePermitScriptInjection(int64 request_id) {
 384   ScopedVector<ScriptInjection>::iterator iter =
 385       pending_injections_.begin();
 386   for (; iter != pending_injections_.end(); ++iter) {
 387     if ((*iter)->request_id() == request_id)
 388       break;
 389   }
 390   if (iter == pending_injections_.end())
 391     return;
 392
 393   // At this point, because the request is present in pending_injections_, we
 394   // know that this is the same page that issued the request (otherwise,
 395   // RVOHelper's DidStartProvisionalLoad callback would have caused it to be
 396   // cleared out).
 397
 398   scoped_ptr<ScriptInjection> injection(*iter);
 399   pending_injections_.weak_erase(iter);
 400
 401   ScriptsRunInfo scripts_run_info;
 402   if (injection->OnPermissionGranted(extensions_->GetByID(
 403                                          injection->extension_id()),
 404                                      &scripts_run_info)) {
 405     scripts_run_info.LogRun(injection->web_frame(), UserScript::RUN_DEFERRED);
 406   }
 407 }
 408
 409 }  // namespace extensions