1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
// 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_BROWSER_DEVTOOLS_DEVTOOLS_WINDOW_H_
#define CHROME_BROWSER_DEVTOOLS_DEVTOOLS_WINDOW_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/string16.h"
#include "chrome/browser/devtools/devtools_file_helper.h"
#include "chrome/browser/devtools/devtools_toggle_action.h"
#include "content/public/browser/devtools_client_host.h"
#include "content/public/browser/devtools_frontend_host_delegate.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/web_contents_delegate.h"
class Browser;
class BrowserWindow;
class DevToolsControllerTest;
class PrefRegistrySyncable;
class Profile;
namespace base {
class Value;
}
namespace content {
class DevToolsAgentHost;
class DevToolsClientHost;
struct FileChooserParams;
class RenderViewHost;
class WebContents;
}
namespace IPC {
class Message;
}
enum DevToolsDockSide {
DEVTOOLS_DOCK_SIDE_UNDOCKED = 0,
DEVTOOLS_DOCK_SIDE_BOTTOM,
DEVTOOLS_DOCK_SIDE_RIGHT,
DEVTOOLS_DOCK_SIDE_MINIMIZED
};
class DevToolsWindow : private content::NotificationObserver,
private content::WebContentsDelegate,
private content::DevToolsFrontendHostDelegate {
public:
static const char kDevToolsApp[];
static std::string GetDevToolsWindowPlacementPrefKey();
static void RegisterUserPrefs(PrefRegistrySyncable* registry);
static DevToolsWindow* GetDockedInstanceForInspectedTab(
content::WebContents* inspected_tab);
static bool IsDevToolsWindow(content::RenderViewHost* window_rvh);
static DevToolsWindow* OpenDevToolsWindowForWorker(
Profile* profile,
content::DevToolsAgentHost* worker_agent);
static DevToolsWindow* CreateDevToolsWindowForWorker(Profile* profile);
static DevToolsWindow* OpenDevToolsWindow(
content::RenderViewHost* inspected_rvh);
static DevToolsWindow* ToggleDevToolsWindow(
Browser* browser,
DevToolsToggleAction action);
static void OpenExternalFrontend(Profile* profile,
const std::string& frontend_uri,
content::DevToolsAgentHost* agent_host);
// Exposed for testing, normal clients should not use this method.
static DevToolsWindow* ToggleDevToolsWindow(
content::RenderViewHost* inspected_rvh,
bool force_open,
DevToolsToggleAction action);
static void InspectElement(
content::RenderViewHost* inspected_rvh, int x, int y);
virtual ~DevToolsWindow();
// Overridden from DevToolsClientHost.
virtual void InspectedContentsClosing() OVERRIDE;
content::RenderViewHost* GetRenderViewHost();
void Show(DevToolsToggleAction action);
content::WebContents* web_contents() { return web_contents_; }
Browser* browser() { return browser_; } // For tests.
DevToolsDockSide dock_side() { return dock_side_; }
content::DevToolsClientHost* GetDevToolsClientHostForTest();
// Returns preferred devtools window width for given |container_width|. It
// tries to use the saved window width, or, if none exists, 1/3 of the
// container width, then clamps to try and ensure both devtools and content
// are at least somewhat visible.
// Called only for the case when devtools window is docked to the side.
int GetWidth(int container_width);
// Returns preferred devtools window height for given |container_height|.
// Uses the same logic as GetWidth.
// Called only for the case when devtools window is docked to bottom.
int GetHeight(int container_height);
// Returns the minimum width devtools window needs.
int GetMinimumWidth();
// Returns the minimum height devtools window needs.
int GetMinimumHeight();
// Stores preferred devtools window width for this instance.
void SetWidth(int width);
// Stores preferred devtools window height for this instance.
void SetHeight(int height);
// Returns the height in minimized mode.
int GetMinimizedHeight();
private:
friend class DevToolsControllerTest;
static DevToolsWindow* Create(Profile* profile,
const GURL& frontend_url,
content::RenderViewHost* inspected_rvh,
DevToolsDockSide dock_side,
bool shared_worker_frontend);
DevToolsWindow(Profile* profile,
const GURL& frontend_url,
content::RenderViewHost* inspected_rvh,
DevToolsDockSide dock_side);
void CreateDevToolsBrowser();
bool FindInspectedBrowserAndTabIndex(Browser**, int* tab);
BrowserWindow* GetInspectedBrowserWindow();
bool IsInspectedBrowserPopup();
void UpdateFrontendDockSide();
void Hide();
// Overridden from content::NotificationObserver.
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
void ScheduleAction(DevToolsToggleAction action);
void DoAction();
static GURL GetDevToolsURL(Profile* profile,
const GURL& base_url,
DevToolsDockSide dock_side,
bool shared_worker_frontend);
void UpdateTheme();
void AddDevToolsExtensionsToClient();
void CallClientFunction(const std::string& function_name,
const base::Value* arg1 = NULL,
const base::Value* arg2 = NULL);
// Overridden from content::WebContentsDelegate.
virtual content::WebContents* OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) OVERRIDE;
virtual void AddNewContents(content::WebContents* source,
content::WebContents* new_contents,
WindowOpenDisposition disposition,
const gfx::Rect& initial_pos,
bool user_gesture,
bool* was_blocked) OVERRIDE;
virtual void CloseContents(content::WebContents* source) OVERRIDE {}
virtual bool PreHandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event,
bool* is_keyboard_shortcut) OVERRIDE;
virtual void HandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event) OVERRIDE;
virtual content::JavaScriptDialogManager*
GetJavaScriptDialogManager() OVERRIDE;
virtual void RunFileChooser(
content::WebContents* web_contents,
const content::FileChooserParams& params) OVERRIDE;
virtual void WebContentsFocused(content::WebContents* contents) OVERRIDE;
static DevToolsWindow* FindDevToolsWindow(content::DevToolsAgentHost*);
static DevToolsWindow* AsDevToolsWindow(content::RenderViewHost*);
// content::DevToolsFrontendHostDelegate overrides.
virtual void ActivateWindow() OVERRIDE;
virtual void ChangeAttachedWindowHeight(unsigned height) OVERRIDE;
virtual void CloseWindow() OVERRIDE;
virtual void MoveWindow(int x, int y) OVERRIDE;
virtual void SetDockSide(const std::string& side) OVERRIDE;
virtual void OpenInNewTab(const std::string& url) OVERRIDE;
virtual void SaveToFile(const std::string& url,
const std::string& content,
bool save_as) OVERRIDE;
virtual void AppendToFile(const std::string& url,
const std::string& content) OVERRIDE;
virtual void RequestFileSystems() OVERRIDE;
virtual void AddFileSystem() OVERRIDE;
virtual void RemoveFileSystem(const std::string& file_system_path) OVERRIDE;
// DevToolsFileHelper callbacks.
void FileSavedAs(const std::string& url);
void AppendedTo(const std::string& url);
void FileSystemsLoaded(
const std::vector<DevToolsFileHelper::FileSystem>& file_systems);
void ShowDevToolsConfirmInfoBar(
const string16& message,
const base::Callback<void(bool)>& callback);
void FileSystemAdded(const DevToolsFileHelper::FileSystem& file_system);
void UpdateBrowserToolbar();
bool IsDocked();
void Restore();
static DevToolsDockSide GetDockSideFromPrefs(Profile* profile);
static std::string SideToString(DevToolsDockSide dock_side);
static DevToolsDockSide SideFromString(const std::string& dock_side);
content::WebContents* GetInspectedWebContents();
class InspectedWebContentsObserver;
scoped_ptr<InspectedWebContentsObserver> inspected_contents_observer_;
class FrontendWebContentsObserver;
scoped_ptr<FrontendWebContentsObserver> frontend_contents_observer_;
Profile* profile_;
content::WebContents* web_contents_;
Browser* browser_;
DevToolsDockSide dock_side_;
bool is_loaded_;
DevToolsToggleAction action_on_load_;
content::NotificationRegistrar registrar_;
scoped_ptr<content::DevToolsClientHost> frontend_host_;
base::WeakPtrFactory<DevToolsWindow> weak_factory_;
scoped_ptr<DevToolsFileHelper> file_helper_;
int width_;
int height_;
DevToolsDockSide dock_side_before_minimized_;
DISALLOW_COPY_AND_ASSIGN(DevToolsWindow);
};
#endif // CHROME_BROWSER_DEVTOOLS_DEVTOOLS_WINDOW_H_
|
