• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.
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 
web_contents()103   WebContents* web_contents() const { return web_contents_.get(); }
window()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