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