content/shell/browser/shell.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 #ifndef CONTENT_SHELL_BROWSER_SHELL_H_
   5 #define CONTENT_SHELL_BROWSER_SHELL_H_
   6
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback_forward.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/string_piece.h"
  14 #include "build/build_config.h"
  15 #include "content/public/browser/web_contents_delegate.h"
  16 #include "content/public/browser/web_contents_observer.h"
  17 #include "ipc/ipc_channel.h"
  18 #include "ui/gfx/native_widget_types.h"
  19 #include "ui/gfx/size.h"
  20
  21 #if defined(OS_ANDROID)
  22 #include "base/android/scoped_java_ref.h"
  23 #elif defined(USE_AURA)
  24 #if defined(OS_CHROMEOS)
  25 namespace wm {
  26 class WMTestHelper;
  27 }
  28 #endif  // defined(OS_CHROMEOS)
  29 namespace views {
  30 class Widget;
  31 class ViewsDelegate;
  32 }
  33 #endif  // defined(USE_AURA)
  34
  35 class GURL;
  36 namespace content {
  37
  38 #if defined(USE_AURA)
  39 class ShellPlatformDataAura;
  40 #endif
  41
  42 class BrowserContext;
  43 class ShellDevToolsFrontend;
  44 class ShellJavaScriptDialogManager;
  45 class SiteInstance;
  46 class WebContents;
  47
  48 // This represents one window of the Content Shell, i.e. all the UI including
  49 // buttons and url bar, as well as the web content area.
  50 class Shell : public WebContentsDelegate,
  51               public WebContentsObserver {
  52  public:
  53   static const int kDefaultTestWindowWidthDip;
  54   static const int kDefaultTestWindowHeightDip;
  55
  56   virtual ~Shell();
  57
  58   void LoadURL(const GURL& url);
  59   void LoadURLForFrame(const GURL& url, const std::string& frame_name);
  60   void LoadDataWithBaseURL(const GURL& url,
  61                            const std::string& data,
  62                            const GURL& base_url);
  63   void GoBackOrForward(int offset);
  64   void Reload();
  65   void Stop();
  66   void UpdateNavigationControls(bool to_different_document);
  67   void Close();
  68   void ShowDevTools();
  69   void ShowDevToolsForElementAt(int x, int y);
  70   void ShowDevToolsForTest(const std::string& settings,
  71                            const std::string& frontend_url);
  72   void CloseDevTools();
  73 #if defined(OS_MACOSX)
  74   // Resizes the web content view to the given dimensions.
  75   void SizeTo(const gfx::Size& content_size);
  76 #endif
  77
  78   // Do one time initialization at application startup.
  79   static void Initialize();
  80
  81   static Shell* CreateNewWindow(BrowserContext* browser_context,
  82                                 const GURL& url,
  83                                 SiteInstance* site_instance,
  84                                 int routing_id,
  85                                 const gfx::Size& initial_size);
  86
  87   // Returns the Shell object corresponding to the given RenderViewHost.
  88   static Shell* FromRenderViewHost(RenderViewHost* rvh);
  89
  90   // Returns the currently open windows.
  91   static std::vector<Shell*>& windows() { return windows_; }
  92
  93   // Closes all windows and returns. This runs a message loop.
  94   static void CloseAllWindows();
  95
  96   // Used for content_browsertests. Called once.
  97   static void SetShellCreatedCallback(
  98       base::Callback<void(Shell*)> shell_created_callback);
  99
 100   WebContents* web_contents() const { return web_contents_.get(); }
 101   gfx::NativeWindow window() { return window_; }
 102
 103 #if defined(OS_MACOSX)
 104   // Public to be called by an ObjC bridge object.
 105   void ActionPerformed(int control);
 106   void URLEntered(std::string url_string);
 107 #elif defined(OS_ANDROID)
 108   // Registers the Android Java to native methods.
 109   static bool Register(JNIEnv* env);
 110 #endif
 111
 112   // WebContentsDelegate
 113   virtual WebContents* OpenURLFromTab(WebContents* source,
 114                                       const OpenURLParams& params) OVERRIDE;
 115   virtual void AddNewContents(WebContents* source,
 116                               WebContents* new_contents,
 117                               WindowOpenDisposition disposition,
 118                               const gfx::Rect& initial_pos,
 119                               bool user_gesture,
 120                               bool* was_blocked) OVERRIDE;
 121   virtual void LoadingStateChanged(WebContents* source,
 122                                    bool to_different_document) OVERRIDE;
 123 #if defined(OS_ANDROID)
 124   virtual void LoadProgressChanged(WebContents* source,
 125                                    double progress) OVERRIDE;
 126 #endif
 127   virtual void ToggleFullscreenModeForTab(WebContents* web_contents,
 128                                           bool enter_fullscreen) OVERRIDE;
 129   virtual bool IsFullscreenForTabOrPending(
 130       const WebContents* web_contents) const OVERRIDE;
 131   virtual void RequestToLockMouse(WebContents* web_contents,
 132                                   bool user_gesture,
 133                                   bool last_unlocked_by_target) OVERRIDE;
 134   virtual void CloseContents(WebContents* source) OVERRIDE;
 135   virtual bool CanOverscrollContent() const OVERRIDE;
 136   virtual void DidNavigateMainFramePostCommit(
 137       WebContents* web_contents) OVERRIDE;
 138   virtual JavaScriptDialogManager* GetJavaScriptDialogManager() OVERRIDE;
 139 #if defined(OS_MACOSX)
 140   virtual void HandleKeyboardEvent(
 141       WebContents* source,
 142       const NativeWebKeyboardEvent& event) OVERRIDE;
 143 #endif
 144   virtual bool AddMessageToConsole(WebContents* source,
 145                                    int32 level,
 146                                    const base::string16& message,
 147                                    int32 line_no,
 148                                    const base::string16& source_id) OVERRIDE;
 149   virtual void RendererUnresponsive(WebContents* source) OVERRIDE;
 150   virtual void ActivateContents(WebContents* contents) OVERRIDE;
 151   virtual void DeactivateContents(WebContents* contents) OVERRIDE;
 152   virtual void WorkerCrashed(WebContents* source) OVERRIDE;
 153   virtual bool HandleContextMenu(const content::ContextMenuParams& params)
 154       OVERRIDE;
 155   virtual void WebContentsFocused(WebContents* contents) OVERRIDE;
 156
 157  private:
 158   enum UIControl {
 159     BACK_BUTTON,
 160     FORWARD_BUTTON,
 161     STOP_BUTTON
 162   };
 163
 164   class DevToolsWebContentsObserver;
 165
 166   explicit Shell(WebContents* web_contents);
 167
 168   // Helper to create a new Shell given a newly created WebContents.
 169   static Shell* CreateShell(WebContents* web_contents,
 170                             const gfx::Size& initial_size);
 171
 172   // Helper for one time initialization of application
 173   static void PlatformInitialize(const gfx::Size& default_window_size);
 174   // Helper for one time deinitialization of platform specific state.
 175   static void PlatformExit();
 176
 177   // Adjust the size when Blink sends 0 for width and/or height.
 178   // This happens when Blink requests a default-sized window.
 179   static gfx::Size AdjustWindowSize(const gfx::Size& initial_size);
 180
 181   // All the methods that begin with Platform need to be implemented by the
 182   // platform specific Shell implementation.
 183   // Called from the destructor to let each platform do any necessary cleanup.
 184   void PlatformCleanUp();
 185   // Creates the main window GUI.
 186   void PlatformCreateWindow(int width, int height);
 187   // Links the WebContents into the newly created window.
 188   void PlatformSetContents();
 189   // Resize the content area and GUI.
 190   void PlatformResizeSubViews();
 191   // Enable/disable a button.
 192   void PlatformEnableUIControl(UIControl control, bool is_enabled);
 193   // Updates the url in the url bar.
 194   void PlatformSetAddressBarURL(const GURL& url);
 195   // Sets whether the spinner is spinning.
 196   void PlatformSetIsLoading(bool loading);
 197   // Set the title of shell window
 198   void PlatformSetTitle(const base::string16& title);
 199   // User right-clicked on the web view
 200   bool PlatformHandleContextMenu(const content::ContextMenuParams& params);
 201 #if defined(OS_ANDROID)
 202   void PlatformToggleFullscreenModeForTab(WebContents* web_contents,
 203                                           bool enter_fullscreen);
 204   bool PlatformIsFullscreenForTabOrPending(
 205       const WebContents* web_contents) const;
 206 #endif
 207 #if defined(TOOLKIT_VIEWS)
 208   void PlatformWebContentsFocused(WebContents* contents);
 209 #endif
 210
 211   gfx::NativeView GetContentView();
 212
 213   // WebContentsObserver
 214   virtual void TitleWasSet(NavigationEntry* entry, bool explicit_set) OVERRIDE;
 215
 216   void InnerShowDevTools(const std::string& settings,
 217                          const std::string& frontend_url);
 218   void OnDevToolsWebContentsDestroyed();
 219
 220   scoped_ptr<ShellJavaScriptDialogManager> dialog_manager_;
 221
 222   scoped_ptr<WebContents> web_contents_;
 223
 224   scoped_ptr<DevToolsWebContentsObserver> devtools_observer_;
 225   ShellDevToolsFrontend* devtools_frontend_;
 226
 227   bool is_fullscreen_;
 228
 229   gfx::NativeWindow window_;
 230   gfx::NativeEditView url_edit_view_;
 231
 232   gfx::Size content_size_;
 233
 234 #if defined(OS_ANDROID)
 235   base::android::ScopedJavaGlobalRef<jobject> java_object_;
 236 #elif defined(USE_AURA)
 237 #if defined(OS_CHROMEOS)
 238   static wm::WMTestHelper* wm_test_helper_;
 239 #endif
 240 #if defined(TOOLKIT_VIEWS)
 241   static views::ViewsDelegate* views_delegate_;
 242
 243   views::Widget* window_widget_;
 244 #endif // defined(TOOLKIT_VIEWS)
 245   static ShellPlatformDataAura* platform_;
 246 #endif  // defined(USE_AURA)
 247
 248   bool headless_;
 249
 250   // A container of all the open windows. We use a vector so we can keep track
 251   // of ordering.
 252   static std::vector<Shell*> windows_;
 253
 254   static base::Callback<void(Shell*)> shell_created_callback_;
 255
 256   // True if the destructur of Shell should post a quit closure on the current
 257   // message loop if the destructed Shell object was the last one.
 258   static bool quit_message_loop_;
 259 };
 260
 261 }  // namespace content
 262
 263 #endif  // CONTENT_SHELL_BROWSER_SHELL_H_