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
|
// Copyright 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 CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_
#define CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_
#include "third_party/WebKit/public/web/WebPlugin.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/sequenced_task_runner_helpers.h"
#include "content/renderer/mouse_lock_dispatcher.h"
#include "content/renderer/render_view_impl.h"
#include "third_party/WebKit/public/web/WebCompositionUnderline.h"
#include "third_party/WebKit/public/web/WebDragStatus.h"
#include "third_party/WebKit/public/web/WebNode.h"
#include "third_party/WebKit/public/web/WebWidget.h"
struct BrowserPluginHostMsg_ResizeGuest_Params;
struct FrameMsg_BuffersSwapped_Params;
namespace content {
class BrowserPluginDelegate;
class ChildFrameCompositingHelper;
class BrowserPluginManager;
class MockBrowserPlugin;
class CONTENT_EXPORT BrowserPlugin :
NON_EXPORTED_BASE(public blink::WebPlugin),
public MouseLockDispatcher::LockTarget {
public:
static BrowserPlugin* GetFromNode(blink::WebNode& node);
RenderViewImpl* render_view() const { return render_view_.get(); }
int render_view_routing_id() const { return render_view_routing_id_; }
int browser_plugin_instance_id() const { return browser_plugin_instance_id_; }
bool attached() const { return attached_; }
bool ready() const { return attached_ || attach_pending_; }
BrowserPluginManager* browser_plugin_manager() const {
return browser_plugin_manager_.get();
}
bool OnMessageReceived(const IPC::Message& msg);
// Update Browser Plugin's DOM Node attribute |attribute_name| with the value
// |attribute_value|.
void UpdateDOMAttribute(const std::string& attribute_name,
const base::string16& attribute_value);
// Returns whether the guest process has crashed.
bool guest_crashed() const { return guest_crashed_; }
// Informs the guest of an updated focus state.
void UpdateGuestFocusState();
// Indicates whether the guest should be focused.
bool ShouldGuestBeFocused() const;
// Embedder's device scale factor changed, we need to update the guest
// renderer.
void UpdateDeviceScaleFactor();
// A request to enable hardware compositing.
void EnableCompositing(bool enable);
// Provided that a guest instance ID has been allocated, this method attaches
// this BrowserPlugin instance to that guest.
void Attach();
// Notify the plugin about a compositor commit so that frame ACKs could be
// sent, if needed.
void DidCommitCompositorFrame();
// Returns whether a message should be forwarded to BrowserPlugin.
static bool ShouldForwardToBrowserPlugin(const IPC::Message& message);
// blink::WebPlugin implementation.
virtual blink::WebPluginContainer* container() const override;
virtual bool initialize(blink::WebPluginContainer* container) override;
virtual void destroy() override;
virtual bool supportsKeyboardFocus() const override;
virtual bool supportsEditCommands() const override;
virtual bool supportsInputMethod() const override;
virtual bool canProcessDrag() const override;
virtual void paint(
blink::WebCanvas* canvas,
const blink::WebRect& rect) override;
virtual void updateGeometry(
const blink::WebRect& frame_rect,
const blink::WebRect& clip_rect,
const blink::WebVector<blink::WebRect>& cut_outs_rects,
bool is_visible) override;
virtual void updateFocus(bool focused) override;
virtual void updateVisibility(bool visible) override;
virtual bool acceptsInputEvents() override;
virtual bool handleInputEvent(
const blink::WebInputEvent& event,
blink::WebCursorInfo& cursor_info) override;
virtual bool handleDragStatusUpdate(blink::WebDragStatus drag_status,
const blink::WebDragData& drag_data,
blink::WebDragOperationsMask mask,
const blink::WebPoint& position,
const blink::WebPoint& screen) override;
virtual void didReceiveResponse(
const blink::WebURLResponse& response) override;
virtual void didReceiveData(const char* data, int data_length) override;
virtual void didFinishLoading() override;
virtual void didFailLoading(const blink::WebURLError& error) override;
virtual void didFinishLoadingFrameRequest(
const blink::WebURL& url,
void* notify_data) override;
virtual void didFailLoadingFrameRequest(
const blink::WebURL& url,
void* notify_data,
const blink::WebURLError& error) override;
virtual bool executeEditCommand(const blink::WebString& name) override;
virtual bool executeEditCommand(const blink::WebString& name,
const blink::WebString& value) override;
virtual bool setComposition(
const blink::WebString& text,
const blink::WebVector<blink::WebCompositionUnderline>& underlines,
int selectionStart,
int selectionEnd) override;
virtual bool confirmComposition(
const blink::WebString& text,
blink::WebWidget::ConfirmCompositionBehavior selectionBehavior) override;
virtual void extendSelectionAndDelete(int before, int after) override;
// MouseLockDispatcher::LockTarget implementation.
void OnLockMouseACK(bool succeeded) override;
void OnMouseLockLost() override;
bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override;
private:
friend class base::DeleteHelper<BrowserPlugin>;
// Only the manager is allowed to create a BrowserPlugin.
friend class BrowserPluginManager;
// For unit/integration tests.
friend class MockBrowserPlugin;
// A BrowserPlugin object is a controller that represents an instance of a
// browser plugin within the embedder renderer process. Once a BrowserPlugin
// does an initial navigation or is attached to a newly created guest, it
// acquires a browser_plugin_instance_id as well. The guest instance ID
// uniquely identifies a guest WebContents that's hosted by this
// BrowserPlugin.
BrowserPlugin(RenderViewImpl* render_view,
blink::WebFrame* frame,
scoped_ptr<BrowserPluginDelegate> delegate);
~BrowserPlugin() override;
int width() const { return plugin_rect_.width(); }
int height() const { return plugin_rect_.height(); }
gfx::Size plugin_size() const { return plugin_rect_.size(); }
gfx::Rect plugin_rect() const { return plugin_rect_; }
float GetDeviceScaleFactor() const;
void ShowSadGraphic();
// Populates BrowserPluginHostMsg_ResizeGuest_Params with resize state.
void PopulateResizeGuestParameters(
const gfx::Size& view_size,
BrowserPluginHostMsg_ResizeGuest_Params* params);
// IPC message handlers.
// Please keep in alphabetical order.
void OnAdvanceFocus(int instance_id, bool reverse);
void OnAttachACK(int browser_plugin_instance_id);
void OnCompositorFrameSwapped(const IPC::Message& message);
void OnGuestGone(int instance_id);
void OnSetContentsOpaque(int instance_id, bool opaque);
void OnSetCursor(int instance_id, const WebCursor& cursor);
void OnSetMouseLock(int instance_id, bool enable);
void OnSetTooltipText(int browser_plugin_instance_id,
const base::string16& tooltip_text);
void OnShouldAcceptTouchEvents(int instance_id, bool accept);
// This indicates whether this BrowserPlugin has been attached to a
// WebContents.
bool attached_;
bool attach_pending_;
const base::WeakPtr<RenderViewImpl> render_view_;
// We cache the |render_view_|'s routing ID because we need it on destruction.
// If the |render_view_| is destroyed before the BrowserPlugin is destroyed
// then we will attempt to access a NULL pointer.
const int render_view_routing_id_;
blink::WebPluginContainer* container_;
gfx::Rect plugin_rect_;
float last_device_scale_factor_;
// Bitmap for crashed plugin. Lazily initialized, non-owning pointer.
SkBitmap* sad_guest_;
bool guest_crashed_;
bool plugin_focused_;
// Tracks the visibility of the browser plugin regardless of the whole
// embedder RenderView's visibility.
bool visible_;
WebCursor cursor_;
bool mouse_locked_;
// This indicates that the BrowserPlugin has a geometry.
bool ready_;
// BrowserPlugin outlives RenderViewImpl in Chrome Apps and so we need to
// store the BrowserPlugin's BrowserPluginManager in a member variable to
// avoid accessing the RenderViewImpl.
const scoped_refptr<BrowserPluginManager> browser_plugin_manager_;
// Used for HW compositing.
scoped_refptr<ChildFrameCompositingHelper> compositing_helper_;
// URL for the embedder frame.
int browser_plugin_instance_id_;
// Indicates whether the guest content is opaque.
bool contents_opaque_;
std::vector<EditCommand> edit_commands_;
scoped_ptr<BrowserPluginDelegate> delegate_;
// Weak factory used in v8 |MakeWeak| callback, since the v8 callback might
// get called after BrowserPlugin has been destroyed.
base::WeakPtrFactory<BrowserPlugin> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(BrowserPlugin);
};
} // namespace content
#endif // CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_
|
