Add support for loading extensions (issue #1947)

- Add CefRequestContext::LoadExtension, CefExtension, CefExtensionHandler and
  related methods/interfaces.
- Add chrome://extensions-support that lists supported Chrome APIs.
- Add CefBrowserHost::SetAutoResizeEnabled and CefDisplayHandler::OnAutoResize
  to support browser resize based on preferred web contents size.
- views: Add support for custom CefMenuButton popups.
- cefclient: Run with `--load-extension=set_page_color` command-line flag for
  an extension loading example. Add `--use-views` on Windows and Linux for an
  even better example.

tests/cefclient/browser/root_window_manager.h

@@ -10,6 +10,7 @@
 
 #include "include/base/cef_scoped_ptr.h"
 #include "include/cef_command_line.h"
+#include "tests/cefclient/browser/image_cache.h"
 #include "tests/cefclient/browser/root_window.h"
 #include "tests/cefclient/browser/temp_window.h"
 
@@ -23,15 +24,9 @@ class RootWindowManager : public RootWindow::Delegate {
   // after all windows have closed.
   explicit RootWindowManager(bool terminate_when_all_windows_closed);
 
-  // Create a new top-level native window that loads |url|.
-  // If |with_controls| is true the window will show controls.
-  // If |with_osr| is true the window will use off-screen rendering.
-  // If |bounds| is empty the default window size and location will be used.
-  // This method can be called from anywhere to create a new top-level window.
-  scoped_refptr<RootWindow> CreateRootWindow(bool with_controls,
-                                             bool with_osr,
-                                             const CefRect& bounds,
-                                             const std::string& url);
+  // Create a new top-level native window. This method can be called from
+  // anywhere.
+  scoped_refptr<RootWindow> CreateRootWindow(const RootWindowConfig& config);
 
   // Create a new native popup window.
   // If |with_controls| is true the window will show controls.
@@ -46,14 +41,46 @@ class RootWindowManager : public RootWindow::Delegate {
       CefRefPtr<CefClient>& client,
       CefBrowserSettings& settings);
 
+  // Create a new top-level native window to host |extension|.
+  // If |with_controls| is true the window will show controls.
+  // If |with_osr| is true the window will use off-screen rendering.
+  // This method can be called from anywhere.
+  scoped_refptr<RootWindow> CreateRootWindowAsExtension(
+      CefRefPtr<CefExtension> extension,
+      const CefRect& source_bounds,
+      CefRefPtr<CefWindow> parent_window,
+      const base::Closure& close_callback,
+      bool with_controls,
+      bool with_osr);
+
+  // Returns true if a window hosting |extension| currently exists. Must be
+  // called on the main thread.
+  bool HasRootWindowAsExtension(CefRefPtr<CefExtension> extension);
+
   // Returns the RootWindow associated with the specified browser ID. Must be
   // called on the main thread.
-  scoped_refptr<RootWindow> GetWindowForBrowser(int browser_id);
+  scoped_refptr<RootWindow> GetWindowForBrowser(int browser_id) const;
+
+  // Returns the currently active/foreground RootWindow. May return NULL. Must
+  // be called on the main thread.
+  scoped_refptr<RootWindow> GetActiveRootWindow() const;
+
+  // Returns the currently active/foreground browser. May return NULL. Safe to
+  // call from any thread.
+  CefRefPtr<CefBrowser> GetActiveBrowser() const;
 
   // Close all existing windows. If |force| is true onunload handlers will not
   // be executed.
   void CloseAllWindows(bool force);
 
+  // Manage the set of loaded extensions. RootWindows will be notified via the
+  // OnExtensionsChanged method.
+  void AddExtension(CefRefPtr<CefExtension> extension);
+
+  bool request_context_per_browser() const {
+    return request_context_per_browser_;
+  }
+
  private:
   // Allow deletion via scoped_ptr only.
   friend struct base::DefaultDeleter<RootWindowManager>;
@@ -61,14 +88,23 @@ class RootWindowManager : public RootWindow::Delegate {
   ~RootWindowManager();
 
   void OnRootWindowCreated(scoped_refptr<RootWindow> root_window);
+  void NotifyExtensionsChanged();
 
   // RootWindow::Delegate methods.
   CefRefPtr<CefRequestContext> GetRequestContext(
       RootWindow* root_window) OVERRIDE;
-  CefRefPtr<CefImage> GetDefaultWindowIcon() OVERRIDE;
+  scoped_refptr<ImageCache> GetImageCache() OVERRIDE;
   void OnTest(RootWindow* root_window, int test_id) OVERRIDE;
   void OnExit(RootWindow* root_window) OVERRIDE;
   void OnRootWindowDestroyed(RootWindow* root_window) OVERRIDE;
+  void OnRootWindowActivated(RootWindow* root_window) OVERRIDE;
+  void OnBrowserCreated(RootWindow* root_window,
+                        CefRefPtr<CefBrowser> browser) OVERRIDE;
+  void CreateExtensionWindow(CefRefPtr<CefExtension> extension,
+                             const CefRect& source_bounds,
+                             CefRefPtr<CefWindow> parent_window,
+                             const base::Closure& close_callback,
+                             bool with_osr) OVERRIDE;
 
   const bool terminate_when_all_windows_closed_;
   bool request_context_per_browser_;
@@ -78,11 +114,24 @@ class RootWindowManager : public RootWindow::Delegate {
   typedef std::set<scoped_refptr<RootWindow>> RootWindowSet;
   RootWindowSet root_windows_;
 
+  // The currently active/foreground RootWindow. Only accessed on the main
+  // thread.
+  scoped_refptr<RootWindow> active_root_window_;
+
+  // The currently active/foreground browser. Access is protected by
+  // |active_browser_lock_;
+  mutable base::Lock active_browser_lock_;
+  CefRefPtr<CefBrowser> active_browser_;
+
   // Singleton window used as the temporary parent for popup browsers.
   TempWindow temp_window_;
 
   CefRefPtr<CefRequestContext> shared_request_context_;
-  CefRefPtr<CefImage> default_window_icon_;
+
+  // Loaded extensions. Only accessed on the main thread.
+  ExtensionSet extensions_;
+
+  scoped_refptr<ImageCache> image_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowManager);
 };