Renderer changes for wiring up shared memory with declarative injection

extensions/renderer/script_injection_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/renderer/script_injection_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/renderer/extension_helper.h"
 #include "extensions/renderer/programmatic_script_injector.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/scripts_run_info.h"
 #include "ipc/ipc_message_macros.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 // The length of time to wait after the DOM is complete to try and run user
@@ skipping 11 matching lines @@
   // RenderViewObserver implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void DidCreateDocumentElement(blink::WebLocalFrame* frame) OVERRIDE;
   virtual void DidFinishDocumentLoad(blink::WebLocalFrame* frame) OVERRIDE;
   virtual void DidFinishLoad(blink::WebLocalFrame* frame) OVERRIDE;
   virtual void DidStartProvisionalLoad(blink::WebLocalFrame* frame) OVERRIDE;
   virtual void FrameDetached(blink::WebFrame* frame) OVERRIDE;
   virtual void OnDestruct() OVERRIDE;
 
   virtual void OnExecuteCode(const ExtensionMsg_ExecuteCode_Params& params);
+  virtual void OnExecuteDeclarativeScript(int tab_id,
+                                          const ExtensionId& extension_id,
+                                          int script_id,
+                                          const GURL& url);
   virtual void OnPermitScriptInjection(int64 request_id);
 
   // Tells the ScriptInjectionManager to run tasks associated with
   // document_idle.
   void RunIdle(blink::WebFrame* frame);
 
   // Indicate that the given |frame| is no longer valid because it is starting
   // a new load or closing.
   void InvalidateFrame(blink::WebFrame* frame);
 
@@ skipping 19 matching lines @@
 ScriptInjectionManager::RVOHelper::~RVOHelper() {
 }
 
 bool ScriptInjectionManager::RVOHelper::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ScriptInjectionManager::RVOHelper, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ExecuteCode, OnExecuteCode)
     IPC_MESSAGE_HANDLER(ExtensionMsg_PermitScriptInjection,
                         OnPermitScriptInjection)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_ExecuteDeclarativeScript,
+                        OnExecuteDeclarativeScript)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ScriptInjectionManager::RVOHelper::DidCreateDocumentElement(
     blink::WebLocalFrame* frame) {
   manager_->InjectScripts(frame, UserScript::DOCUMENT_START);
 }
 
@@ skipping 43 matching lines @@
 
 void ScriptInjectionManager::RVOHelper::OnDestruct() {
   manager_->RemoveObserver(this);
 }
 
 void ScriptInjectionManager::RVOHelper::OnExecuteCode(
     const ExtensionMsg_ExecuteCode_Params& params) {
   manager_->HandleExecuteCode(params, render_view());
 }
 
+void ScriptInjectionManager::RVOHelper::OnExecuteDeclarativeScript(
+    int tab_id,
+    const ExtensionId& extension_id,
+    int script_id,
+    const GURL& url) {
+  blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  CHECK(main_frame);
+
+  // Begin script injeciton workflow only if the current URL is identical to
+  // the one that matched declarative conditions in the browser.
+  if (main_frame->top()->document().url() == url) {

[Devlin, 2014/08/28 21:38:10]

This should *probably* be done better.  This doesn't check, for instance,
reloading the page.  I think we have page_ids that are renderer-specific, so I
could imagine a general flow of:
Renderer notifies browser of a potential injection point and records the id.
Browser says "Inject!"
Renderer compares the page ids.

But... again, we can make that a TODO for now.

[Mark Dittmer, 2014/08/28 23:49:47]

Done.

+    manager_->HandleExecuteDeclarativeScript(main_frame,
+                                             tab_id,
+                                             extension_id,
+                                             script_id,
+                                             url);
+  }
+}
+
 void ScriptInjectionManager::RVOHelper::OnPermitScriptInjection(
     int64 request_id) {
   manager_->HandlePermitScriptInjection(request_id);
 }
 
 void ScriptInjectionManager::RVOHelper::RunIdle(blink::WebFrame* frame) {
   // Only notify the manager if the frame hasn't either been removed or already
   // had idle run since the task to RunIdle() was posted.
   if (pending_idle_frames_.count(frame) > 0) {
     manager_->InjectScripts(frame, UserScript::DOCUMENT_IDLE);
@@ skipping 153 matching lines @@
   ScriptsRunInfo scripts_run_info;
   FrameStatusMap::const_iterator iter = frame_statuses_.find(main_frame);
   if (!injection->TryToInject(
           iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second,
           extensions_->GetByID(injection->extension_id()),
           &scripts_run_info)) {
     pending_injections_.push_back(injection.release());
   }
 }
 
+void ScriptInjectionManager::HandleExecuteDeclarativeScript(
+    blink::WebFrame* web_frame,
+    int tab_id,
+    const ExtensionId& extension_id,
+    int script_id,
+    const GURL& url) {
+  const Extension* extension = extensions_->GetByID(extension_id);
+  scoped_ptr<ScriptInjection> injection =
+      user_script_set_manager_->GetInjectionForDeclarativeScript(
+          script_id,
+          web_frame,
+          tab_id,
+          url,
+          extension);
+  if (injection.get()) {
+    ScriptsRunInfo scripts_run_info;
+    // TODO(markdittmer): Use return value of TryToInject for error handling.
+    injection->TryToInject(UserScript::BROWSER_DRIVEN,
+                           extension,
+                           &scripts_run_info);
+    scripts_run_info.LogRun(web_frame, UserScript::BROWSER_DRIVEN);

[Devlin, 2014/08/28 21:38:10]

Even if we don't use the result of TryToInject yet, we definitely shouldn't log
if we didn't inject anything.

[Mark Dittmer, 2014/08/28 23:49:47]

As per our conversation, ScriptInjection::TryToInject reads: "This returns true
if the script has either injected or will never inject (i.e., if the object is
done)". As such, there is no way to know the difference, but LogRun shouldn't
log anything if no scripts have been run, so we'll leave this as-is.

+  }
+}
+
 void ScriptInjectionManager::HandlePermitScriptInjection(int64 request_id) {
   ScopedVector<ScriptInjection>::iterator iter =
       pending_injections_.begin();
   for (; iter != pending_injections_.end(); ++iter) {
     if ((*iter)->request_id() == request_id)
       break;
   }
   if (iter == pending_injections_.end())
     return;
 
   // At this point, because the request is present in pending_injections_, we
   // know that this is the same page that issued the request (otherwise,
   // RVOHelper's DidStartProvisionalLoad callback would have caused it to be
   // cleared out).
 
   scoped_ptr<ScriptInjection> injection(*iter);
   pending_injections_.weak_erase(iter);
 
   ScriptsRunInfo scripts_run_info;
   if (injection->OnPermissionGranted(extensions_->GetByID(
                                          injection->extension_id()),
                                      &scripts_run_info)) {
     scripts_run_info.LogRun(injection->web_frame(), UserScript::RUN_DEFERRED);
   }
 }
 
 }  // namespace extensions