Lazy load chrome.* APIs

chrome/renderer/extensions/chrome_v8_context.h

 // Copyright (c) 2012 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 CHROME_RENDERER_EXTENSIONS_CHROME_V8_CONTEXT_H_
 #define CHROME_RENDERER_EXTENSIONS_CHROME_V8_CONTEXT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 // require adding WebFrame::GetIsolatedWorldIdByV8Context() to WebCore, but then
 // we won't need this object and it's a bit less state to keep track of.
 class ChromeV8Context {
  public:
   ChromeV8Context(v8::Handle<v8::Context> context,
                   WebKit::WebFrame* frame,
                   const Extension* extension,
                   Feature::Context context_type);
   ~ChromeV8Context();
 
+  // Clears the WebFrame for this contexts and invalidates the associated
+  // ModuleSystem.
+  void Invalidate();
+
   v8::Handle<v8::Context> v8_context() const {
     return v8_context_;
   }
 
   const Extension* extension() const {
     return extension_.get();
   }
 
   WebKit::WebFrame* web_frame() const {
     return web_frame_;
   }
-  void clear_web_frame() {
-    web_frame_ = NULL;
-  }
 
   Feature::Context context_type() const {
     return context_type_;
   }
 
   void set_module_system(scoped_ptr<ModuleSystem> module_system) {
     module_system_ = module_system.Pass();
   }
 
   ModuleSystem* module_system() { return module_system_.get(); }
@@ skipping 30 matching lines @@
   bool CallChromeHiddenMethod(
       const std::string& function_name,
       int argc,
       v8::Handle<v8::Value>* argv,
       v8::Handle<v8::Value>* result) const;
 
   // Returns the set of extension APIs that are available to this context. If no
   // APIs are available, returns an empty set.
   const std::set<std::string>& GetAvailableExtensionAPIs();
 
+  Feature::Availability GetAvailability(const std::string& api_name);
+
   // Returns a string description of the type of context this is.
   std::string GetContextTypeDescription();
 
  private:
   // The v8 context the bindings are accessible to. We keep a strong reference
   // to it for simplicity. In the case of content scripts, this is necessary
   // because we want all scripts from the same extension for the same frame to
   // run in the same context, so we can't have the contexts being GC'd if
   // nothing is happening. In the case of page contexts, this isn't necessary
   // since the DOM keeps the context alive, but it makes things simpler to not
   // distinguish the two cases.
   v8::Persistent<v8::Context> v8_context_;
 
   // The WebFrame associated with this context. This can be NULL because this
   // object can outlive is destroyed asynchronously.
   WebKit::WebFrame* web_frame_;
 
   // The extension associated with this context, or NULL if there is none. This
   // might be a hosted app in the case that this context is hosting a web URL.
   scoped_refptr<const Extension> extension_;
 
   // The type of context.
   Feature::Context context_type_;
 
   // Owns and structures the JS that is injected to set up extension bindings.
   scoped_ptr<ModuleSystem> module_system_;
 
   // The extension APIs available to this context.
-  scoped_ptr<std::set<std::string> > available_extension_apis_;
+  std::set<std::string> available_extension_apis_;
+  bool available_extension_apis_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeV8Context);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_RENDERER_EXTENSIONS_CHROME_V8_CONTEXT_H_