Move Extension ScriptContext creation into ScriptContextSet.

extensions/renderer/dispatcher.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 EXTENSIONS_RENDERER_DISPATCHER_H_
 #define EXTENSIONS_RENDERER_DISPATCHER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/memory/scoped_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/timer/timer.h"
 #include "content/public/renderer/render_process_observer.h"
 #include "extensions/common/event_filter.h"
+#include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/renderer/resource_bundle_source_map.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/user_script_set_manager.h"
 #include "extensions/renderer/v8_schema_registry.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
@@ skipping 18 matching lines @@
 class ListValue;
 }
 
 namespace content {
 class RenderThread;
 }
 
 namespace extensions {
 class ContentWatcher;
 class DispatcherDelegate;
-class Extension;
 class FilteredEventRouter;
 class ManifestPermissionSet;
 class RequestSender;
 class ScriptContext;
 class ScriptInjectionManager;
 struct Message;
 
 // Dispatches extension control messages sent to the renderer and stores
 // renderer extension related state.
 class Dispatcher : public content::RenderProcessObserver,
                    public UserScriptSetManager::Observer {
  public:
   explicit Dispatcher(DispatcherDelegate* delegate);
   ~Dispatcher() override;
 
   const std::set<std::string>& function_names() const {
     return function_names_;
   }
 
   const ExtensionSet* extensions() const { return &extensions_; }
 
   const ScriptContextSet& script_context_set() const {
-    return script_context_set_;
+    return *script_context_set_;
   }
 
   V8SchemaRegistry* v8_schema_registry() { return v8_schema_registry_.get(); }
 
   ContentWatcher* content_watcher() { return content_watcher_.get(); }
 
   RequestSender* request_sender() { return request_sender_.get(); }
 
   void OnRenderViewCreated(content::RenderView* render_view);
 
   bool IsExtensionActive(const std::string& extension_id) const;
 
-  // Finds the extension for the JavaScript context associated with the
-  // specified |frame| and isolated world. If |world_id| is zero, finds the
-  // extension ID associated with the main world's JavaScript context. If the
-  // JavaScript context isn't from an extension, returns empty string.
-  const Extension* GetExtensionFromFrameAndWorld(const blink::WebFrame* frame,
-                                                 int world_id,
-                                                 bool use_effective_url);
-
   void DidCreateScriptContext(blink::WebLocalFrame* frame,
                               const v8::Handle<v8::Context>& context,
                               int extension_group,
                               int world_id);
 
   void WillReleaseScriptContext(blink::WebLocalFrame* frame,
                                 const v8::Handle<v8::Context>& context,
                                 int world_id);
 
   void DidCreateDocumentElement(blink::WebFrame* frame);
@@ skipping 125 matching lines @@
   // Updates a web page context with any content capabilities granted by active
   // extensions.
   void UpdateContentCapabilities(ScriptContext* context);
 
   // Inserts static source code into |source_map_|.
   void PopulateSourceMap();
 
   // Returns whether the current renderer hosts a platform app.
   bool IsWithinPlatformApp();
 
-  bool IsSandboxedPage(const GURL& url) const;
-
-  // Returns the Feature::Context type of context for a JavaScript context.
-  Feature::Context ClassifyJavaScriptContext(
-      const Extension* extension,
-      int extension_group,
-      const GURL& url,
-      const blink::WebSecurityOrigin& origin);
-
   // Gets |field| from |object| or creates it as an empty object if it doesn't
   // exist.
   v8::Handle<v8::Object> GetOrCreateObject(const v8::Handle<v8::Object>& object,
                                            const std::string& field,
                                            v8::Isolate* isolate);
 
   v8::Handle<v8::Object> GetOrCreateBindObjectIfAvailable(
       const std::string& api_name,
       std::string* bind_name,
       ScriptContext* context);
 
   // The delegate for this dispatcher. Not owned, but must extend beyond the
   // Dispatcher's own lifetime.
   DispatcherDelegate* delegate_;
 
   // True if the IdleNotification timer should be set.
   bool set_idle_notifications_;
 
   // Contains all loaded extensions.  This is essentially the renderer
   // counterpart to ExtensionService in the browser. It contains information
   // about all extensions currently loaded by the browser.
   ExtensionSet extensions_;
 
   // The IDs of extensions that failed to load, mapped to the error message
   // generated on failure.
   std::map<std::string, std::string> extension_load_errors_;
 
   // All the bindings contexts that are currently loaded for this renderer.
   // There is zero or one for each v8 context.
-  ScriptContextSet script_context_set_;
+  scoped_ptr<ScriptContextSet> script_context_set_;
 
   scoped_ptr<ContentWatcher> content_watcher_;
 
   scoped_ptr<UserScriptSetManager> user_script_set_manager_;
 
   scoped_ptr<ScriptInjectionManager> script_injection_manager_;
 
   // Same as above, but on a longer timer and will run even if the process is
   // not idle, to ensure that IdleHandle gets called eventually.
   scoped_ptr<base::RepeatingTimer<content::RenderThread> > forced_idle_timer_;
 
   // All declared function names.
   std::set<std::string> function_names_;
 
   // The extensions and apps that are active in this process.
-  std::set<std::string> active_extension_ids_;
+  ExtensionIdSet active_extension_ids_;
 
   ResourceBundleSourceMap source_map_;
 
   // Cache for the v8 representation of extension API schemas.
   scoped_ptr<V8SchemaRegistry> v8_schema_registry_;
 
   // Sends API requests to the extension host.
   scoped_ptr<RequestSender> request_sender_;
 
   // The platforms system font family and size;
@@ skipping 13 matching lines @@
 
   // Status of webrequest usage.
   bool webrequest_used_;
 
   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_DISPATCHER_H_