Change ScriptInjection to work with WebLocalFrames.

extensions/renderer/script_injection.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.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_handlers/csp_info.h"
 #include "extensions/renderer/dom_activity_logger.h"
 #include "extensions/renderer/extension_groups.h"
 #include "extensions/renderer/extensions_renderer_client.h"
 #include "third_party/WebKit/public/platform/WebString.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/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 typedef std::map<std::string, int> IsolatedWorldMap;
@@ skipping 17 matching lines @@
        child_frame = child_frame->nextSibling()) {
     frames_vector->push_back(child_frame);
     AppendAllChildFrames(child_frame, frames_vector);
   }
 }
 
 // Gets the isolated world ID to use for the given |extension| in the given
 // |frame|. If no isolated world has been created for that extension,
 // one will be created and initialized.
 int GetIsolatedWorldIdForExtension(const Extension* extension,
-                                   blink::WebFrame* frame) {
+                                   blink::WebLocalFrame* frame) {
   static int g_next_isolated_world_id =
       ExtensionsRendererClient::Get()->GetLowestIsolatedWorldId();
 
   IsolatedWorldMap& isolated_worlds = g_isolated_worlds.Get();
 
   int id = 0;
   IsolatedWorldMap::iterator iter = isolated_worlds.find(extension->id());
   if (iter != isolated_worlds.end()) {
     id = iter->second;
   } else {
@@ skipping 34 matching lines @@
   return std::string();
 }
 
 // static
 void ScriptInjection::RemoveIsolatedWorld(const std::string& extension_id) {
   g_isolated_worlds.Get().erase(extension_id);
 }
 
 ScriptInjection::ScriptInjection(
     scoped_ptr<ScriptInjector> injector,
-    blink::WebFrame* web_frame,
+    blink::WebLocalFrame* web_frame,
     const std::string& extension_id,
     UserScript::RunLocation run_location,
     int tab_id)
     : injector_(injector.Pass()),
       web_frame_(web_frame),
       extension_id_(extension_id),
       run_location_(run_location),
       tab_id_(tab_id),
       request_id_(kInvalidRequestId),
       complete_(false) {
@@ skipping 88 matching lines @@
 
   bool inject_js = injector_->ShouldInjectJs(run_location_);
   bool inject_css = injector_->ShouldInjectCss(run_location_);
   DCHECK(inject_js || inject_css);
 
   scoped_ptr<base::ListValue> execution_results(new base::ListValue());
   GURL top_url = web_frame_->top()->document().url();
   for (std::vector<blink::WebFrame*>::iterator iter = frame_vector.begin();
        iter != frame_vector.end();
        ++iter) {
-    blink::WebFrame* frame = *iter;
+    // TODO(dcheng): Unfortunately, the code as written won't work in an OOPI
+    // world. This is just a temporary hack to make things compile.
+    blink::WebLocalFrame* frame = (*iter)->toWebLocalFrame();
 
     // We recheck access here in the renderer for extra safety against races
     // with navigation, but different frames can have different URLs, and the
     // extension might only have access to a subset of them.
     // For child frames, we just skip ones the extension doesn't have access
     // to and carry on.
     // Note: we don't consider ACCESS_WITHHELD because there is nowhere to
     // surface a request for a child frame.
     // TODO(rdevlin.cronin): We should ask for permission somehow.
     if (injector_->CanExecuteOnFrame(extension, frame, tab_id_, top_url) ==
         PermissionsData::ACCESS_DENIED) {
       DCHECK(frame->parent());
       continue;
     }
     if (inject_js)
       InjectJs(extension, frame, execution_results.get());
     if (inject_css)
       InjectCss(frame);
   }
 
   complete_ = true;
   injector_->OnInjectionComplete(execution_results.Pass(),
                                  scripts_run_info,
                                  run_location_);
 }
 
 void ScriptInjection::InjectJs(const Extension* extension,
-                               blink::WebFrame* frame,
+                               blink::WebLocalFrame* frame,
                                base::ListValue* execution_results) {
   std::vector<blink::WebScriptSource> sources =
       injector_->GetJsSources(run_location_);
   bool in_main_world = injector_->ShouldExecuteInMainWorld();
   int world_id = in_main_world
                      ? DOMActivityLogger::kMainWorldId
                      : GetIsolatedWorldIdForExtension(extension, frame);
   bool expects_results = injector_->ExpectsResults();
 
   base::ElapsedTimer exec_timer;
@@ skipping 35 matching lines @@
     v8::Local<v8::Context> context = frame->mainWorldScriptContext();
     scoped_ptr<base::Value> result(
         v8_converter->FromV8Value(script_value, context));
     // Always append an execution result (i.e. no result == null result)
     // so that |execution_results| lines up with the frames.
     execution_results->Append(result.get() ? result.release()
                                            : base::Value::CreateNullValue());
   }
 }
 
-void ScriptInjection::InjectCss(blink::WebFrame* frame) {
+void ScriptInjection::InjectCss(blink::WebLocalFrame* frame) {
   std::vector<std::string> css_sources =
       injector_->GetCssSources(run_location_);
   for (std::vector<std::string>::const_iterator iter = css_sources.begin();
        iter != css_sources.end();
        ++iter) {
     frame->document().insertStyleSheet(blink::WebString::fromUTF8(*iter));
   }
 }
 
 }  // namespace extensions