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
|
// 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 UI_VIEWS_CONTROLS_WEBVIEW_WEBVIEW_H_
#define UI_VIEWS_CONTROLS_WEBVIEW_WEBVIEW_H_
#include <stdint.h>
#include <memory>
#include "base/callback.h"
#include "base/macros.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/browser/web_contents_observer.h"
#include "ui/accessibility/ax_mode_observer.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/controls/native/native_view_host.h"
#include "ui/views/controls/webview/webview_export.h"
#include "ui/views/view.h"
namespace views {
// Provides a view of a WebContents instance. WebView can be used standalone,
// creating and displaying an internally-owned WebContents; or within a full
// browser where the browser swaps its own WebContents instances in/out (e.g.,
// for browser tabs).
//
// WebView creates and owns a single child view, a NativeViewHost, which will
// hold and display the native view provided by a WebContents.
//
// EmbedFullscreenWidgetMode: When enabled, WebView will observe for WebContents
// fullscreen changes and automatically swap the normal native view with the
// fullscreen native view (if different). In addition, if the WebContents is
// being screen-captured, the view will be centered within WebView, sized to
// the aspect ratio of the capture video resolution, and scaling will be avoided
// whenever possible.
class WEBVIEW_EXPORT WebView : public View,
public content::WebContentsDelegate,
public content::WebContentsObserver,
public ui::AXModeObserver {
public:
METADATA_HEADER(WebView);
explicit WebView(content::BrowserContext* browser_context = nullptr);
~WebView() override;
// This creates a WebContents if |kBrowserContext| has been set and there is
// not yet a WebContents associated with this WebView, otherwise it will
// return a nullptr.
content::WebContents* GetWebContents();
// WebView does not assume ownership of WebContents set via this method, only
// those it implicitly creates via GetWebContents() above.
void SetWebContents(content::WebContents* web_contents);
content::BrowserContext* GetBrowserContext();
void SetBrowserContext(content::BrowserContext* browser_context);
// Loads the initial URL to display in the attached WebContents. Creates the
// WebContents if none is attached yet. Note that this is intended as a
// convenience for loading the initial URL, and so URLs are navigated with
// PAGE_TRANSITION_AUTO_TOPLEVEL, so this is not intended as a general purpose
// navigation method - use WebContents' API directly.
void LoadInitialURL(const GURL& url);
// Controls how the attached WebContents is resized.
// false = WebContents' views' bounds are updated continuously as the
// WebView's bounds change (default).
// true = WebContents' views' position is updated continuously but its size
// is not (which may result in some clipping or under-painting) until
// a continuous size operation completes. This allows for smoother
// resizing performance during interactive resizes and animations.
void SetFastResize(bool fast_resize);
// If enabled, this will make the WebView's preferred size dependent on the
// WebContents' size.
void EnableSizingFromWebContents(const gfx::Size& min_size,
const gfx::Size& max_size);
// If provided, this View will be shown in place of the web contents
// when the web contents is in a crashed state. This is cleared automatically
// if the web contents is changed.
void SetCrashedOverlayView(View* crashed_overlay_view);
// Sets whether this is the primary web contents for the window.
void set_is_primary_web_contents_for_window(bool is_primary) {
is_primary_web_contents_for_window_ = is_primary;
}
// When used to host UI, we need to explicitly allow accelerators to be
// processed. Default is false.
void set_allow_accelerators(bool allow_accelerators) {
allow_accelerators_ = allow_accelerators;
}
// Overridden from content::WebContentsDelegate:
void ResizeDueToAutoResize(content::WebContents* source,
const gfx::Size& new_size) override;
NativeViewHost* holder() { return holder_; }
using WebContentsCreator =
base::RepeatingCallback<std::unique_ptr<content::WebContents>(
content::BrowserContext*)>;
// An instance of this class registers a WebContentsCreator on construction
// and deregisters the WebContentsCreator on destruction.
class WEBVIEW_EXPORT ScopedWebContentsCreatorForTesting {
public:
explicit ScopedWebContentsCreatorForTesting(WebContentsCreator creator);
~ScopedWebContentsCreatorForTesting();
private:
DISALLOW_COPY_AND_ASSIGN(ScopedWebContentsCreatorForTesting);
};
protected:
// Called when the web contents is successfully attached.
virtual void OnWebContentsAttached() {}
// Called when letterboxing (scaling the native view to preserve aspect
// ratio) is enabled or disabled.
virtual void OnLetterboxingChanged() {}
bool is_letterboxing() const { return is_letterboxing_; }
const gfx::Size& min_size() const { return min_size_; }
const gfx::Size& max_size() const { return max_size_; }
// Overridden from View:
void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
void ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) override;
bool SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) override;
bool OnMousePressed(const ui::MouseEvent& event) override;
void OnFocus() override;
void AboutToRequestFocusFromTabTraversal(bool reverse) override;
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
gfx::NativeViewAccessible GetNativeViewAccessible() override;
void AddedToWidget() override;
// Overridden from content::WebContentsObserver:
void RenderViewCreated(content::RenderViewHost* render_view_host) override;
void RenderViewReady() override;
void RenderViewDeleted(content::RenderViewHost* render_view_host) override;
void RenderViewHostChanged(content::RenderViewHost* old_host,
content::RenderViewHost* new_host) override;
void WebContentsDestroyed() override;
void DidToggleFullscreenModeForTab(bool entered_fullscreen,
bool will_cause_resize) override;
// Workaround for MSVC++ linker bug/feature that requires
// instantiation of the inline IPC::Listener methods in all translation units.
void OnChannelConnected(int32_t peer_id) override {}
void OnChannelError() override {}
void OnBadMessageReceived(const IPC::Message& message) override {}
void OnWebContentsFocused(
content::RenderWidgetHost* render_widget_host) override;
void RenderProcessGone(base::TerminationStatus status) override;
void AXTreeIDForMainFrameHasChanged() override;
// Override from ui::AXModeObserver
void OnAXModeAdded(ui::AXMode mode) override;
private:
friend class WebViewUnitTest;
void AttachWebContentsNativeView();
void DetachWebContentsNativeView();
void UpdateCrashedOverlayView();
void NotifyAccessibilityWebContentsChanged();
// Registers for ResizeDueToAutoResize() notifications from the
// RenderWidgetHostView whenever it is created or changes, if
// EnableSizingFromWebContents() has been called.
void MaybeEnableAutoResize();
// Create a regular or test web contents (based on whether we're running
// in a unit test or not).
std::unique_ptr<content::WebContents> CreateWebContents(
content::BrowserContext* browser_context);
NativeViewHost* const holder_ =
AddChildView(std::make_unique<NativeViewHost>());
// Non-NULL if |web_contents()| was created and is owned by this WebView.
std::unique_ptr<content::WebContents> wc_owner_;
// Set to true when |holder_| is letterboxed (scaled to be smaller than this
// view, to preserve its aspect ratio).
bool is_letterboxing_ = false;
content::BrowserContext* browser_context_;
bool allow_accelerators_ = false;
View* crashed_overlay_view_ = nullptr;
bool is_primary_web_contents_for_window_ = false;
// Minimum and maximum sizes to determine WebView bounds for auto-resizing.
// Empty if auto resize is not enabled.
gfx::Size min_size_;
gfx::Size max_size_;
// Tracks the child accessibility tree id which is associated with the
// WebContents's main RenderFrameHost.
ui::AXTreeID child_ax_tree_id_;
DISALLOW_COPY_AND_ASSIGN(WebView);
};
} // namespace views
#endif // UI_VIEWS_CONTROLS_WEBVIEW_WEBVIEW_H_
|
