Move most scripting-related methods from WebFrame to WebLocalFrame.

third_party/WebKit/public/web/WebLocalFrame.h

 // 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.
 
 #ifndef WebLocalFrame_h
 #define WebLocalFrame_h
 
 #include <set>
 #include "WebCompositionUnderline.h"
 #include "WebFrame.h"
@@ skipping 32 matching lines @@
 class WebTextCheckClient;
 class WebURLLoader;
 enum class WebCachePolicy;
 enum class WebSandboxFlags;
 enum class WebTreeScopeType;
 struct WebConsoleMessage;
 struct WebContentSecurityPolicyViolation;
 struct WebFindOptions;
 struct WebFloatRect;
 struct WebPrintPresetOptions;
+struct WebScriptSource;
 struct WebSourceLocation;
 
 // Interface for interacting with in process frames. This contains methods that
 // require interacting with a frame's document.
 // FIXME: Move lots of methods from WebFrame in here.
 class WebLocalFrame : public WebFrame {
  public:
   // Creates a WebFrame. Delete this WebFrame by calling WebFrame::close().
   // WebFrameClient may not be null.
   BLINK_EXPORT static WebLocalFrame* Create(WebTreeScopeType,
@@ skipping 227 matching lines @@
   // Returns the value for a page property that is only defined when printing.
   // printBegin must have been called before this method.
   virtual WebString PageProperty(const WebString& property_name,
                                  int page_index) = 0;
 
   // Scripting --------------------------------------------------------------
 
   // Executes script in the context of the current page.
   virtual void ExecuteScript(const WebScriptSource&) = 0;
 
+  // Executes JavaScript in a new world associated with the web frame.
+  // The script gets its own global scope and its own prototypes for
+  // intrinsic JavaScript objects (String, Array, and so-on). It also
+  // gets its own wrappers for all DOM nodes and DOM constructors.
+  //
+  // worldID must be > 0 (as 0 represents the main world).
+  // worldID must be < EmbedderWorldIdLimit, high number used internally.
+  virtual void ExecuteScriptInIsolatedWorld(int world_id,
+                                            const WebScriptSource* sources,
+                                            unsigned num_sources) = 0;
+
+  // worldID must be > 0 (as 0 represents the main world).
+  // worldID must be < EmbedderWorldIdLimit, high number used internally.
+  // DEPRECATED: Use WebLocalFrame::requestExecuteScriptInIsolatedWorld.
+  virtual void ExecuteScriptInIsolatedWorld(
+      int world_id,
+      const WebScriptSource* sources_in,
+      unsigned num_sources,
+      WebVector<v8::Local<v8::Value>>* results) = 0;
+
+  // Associates an isolated world (see above for description) with a security
+  // origin. XMLHttpRequest instances used in that world will be considered
+  // to come from that origin, not the frame's.
+  virtual void SetIsolatedWorldSecurityOrigin(int world_id,
+                                              const WebSecurityOrigin&) = 0;
+
+  // Associates a content security policy with an isolated world. This policy
+  // should be used when evaluating script in the isolated world, and should
+  // also replace a protected resource's CSP when evaluating resources
+  // injected into the DOM.
+  //
+  // FIXME: Setting this simply bypasses the protected resource's CSP. It
+  //     doesn't yet restrict the isolated world to the provided policy.
+  virtual void SetIsolatedWorldContentSecurityPolicy(int world_id,
+                                                     const WebString&) = 0;
+
+  // Calls window.gc() if it is defined.
+  virtual void CollectGarbage() = 0;
+
+  // Executes script in the context of the current page and returns the value
+  // that the script evaluated to.
+  // DEPRECATED: Use WebLocalFrame::requestExecuteScriptAndReturnValue.
+  virtual v8::Local<v8::Value> ExecuteScriptAndReturnValue(
+      const WebScriptSource&) = 0;
+
+  // Call the function with the given receiver and arguments, bypassing
+  // canExecute().
+  virtual v8::Local<v8::Value> CallFunctionEvenIfScriptDisabled(
+      v8::Local<v8::Function>,
+      v8::Local<v8::Value>,
+      int argc,
+      v8::Local<v8::Value> argv[]) = 0;
+
   // Returns the V8 context for associated with the main world and this
   // frame. There can be many V8 contexts associated with this frame, one for
   // each isolated world and one for the main world. If you don't know what
   // the "main world" or an "isolated world" is, then you probably shouldn't
   // be calling this API.
   virtual v8::Local<v8::Context> MainWorldScriptContext() const = 0;
 
   // Executes script in the context of the current page and returns the value
   // that the script evaluated to with callback. Script execution can be
   // suspend.
@@ skipping 331 matching lines @@
   // to call these on a WebLocalFrame.
   bool IsWebLocalFrame() const override = 0;
   WebLocalFrame* ToWebLocalFrame() override = 0;
   bool IsWebRemoteFrame() const override = 0;
   WebRemoteFrame* ToWebRemoteFrame() override = 0;
 };
 
 }  // namespace blink
 
 #endif  // WebLocalFrame_h