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
|
// Copyright 2013 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 COMPONENTS_PLUGINS_RENDERER_WEBVIEW_PLUGIN_H_
#define COMPONENTS_PLUGINS_RENDERER_WEBVIEW_PLUGIN_H_
#include <list>
#include "base/memory/scoped_ptr.h"
#include "base/sequenced_task_runner_helpers.h"
#include "third_party/WebKit/public/platform/WebCursorInfo.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebURLResponse.h"
#include "third_party/WebKit/public/web/WebFrameClient.h"
#include "third_party/WebKit/public/web/WebPlugin.h"
#include "third_party/WebKit/public/web/WebViewClient.h"
struct WebPreferences;
namespace blink {
class WebMouseEvent;
}
// This class implements the WebPlugin interface by forwarding drawing and
// handling input events to a WebView.
// It can be used as a placeholder for an actual plugin, using HTML for the UI.
// To show HTML data inside the WebViewPlugin,
// call web_view->mainFrame()->loadHTMLString() with the HTML data and a fake
// chrome:// URL as origin.
class WebViewPlugin : public blink::WebPlugin,
public blink::WebViewClient,
public blink::WebFrameClient {
public:
class Delegate {
public:
// Bind |frame| to a Javascript object, enabling the delegate to receive
// callback methods from Javascript inside the WebFrame.
// This method is called from WebFrameClient::didClearWindowObject.
virtual void BindWebFrame(blink::WebFrame* frame) = 0;
// Called upon a context menu event.
virtual void ShowContextMenu(const blink::WebMouseEvent&) = 0;
};
explicit WebViewPlugin(Delegate* delegate);
// Convenience method to set up a new WebViewPlugin using |preferences|
// and displaying |html_data|. |url| should be a (fake) chrome:// URL; it is
// only used for navigation and never actually resolved.
static WebViewPlugin* Create(Delegate* delegate,
const WebPreferences& preferences,
const std::string& html_data,
const GURL& url);
blink::WebView* web_view() { return web_view_; }
// When loading a plug-in document (i.e. a full page plug-in not embedded in
// another page), we save all data that has been received, and replay it with
// this method on the actual plug-in.
void ReplayReceivedData(blink::WebPlugin* plugin);
void RestoreTitleText();
// WebPlugin methods:
virtual blink::WebPluginContainer* container() const;
virtual bool initialize(blink::WebPluginContainer*);
virtual void destroy();
virtual NPObject* scriptableObject();
virtual struct _NPP* pluginNPP();
virtual bool getFormValue(blink::WebString& value);
virtual void paint(blink::WebCanvas* canvas, const blink::WebRect& rect);
// Coordinates are relative to the containing window.
virtual void updateGeometry(
const blink::WebRect& frame_rect,
const blink::WebRect& clip_rect,
const blink::WebVector<blink::WebRect>& cut_out_rects,
bool is_visible);
virtual void updateFocus(bool) {}
virtual void updateVisibility(bool) {}
virtual bool acceptsInputEvents();
virtual bool handleInputEvent(const blink::WebInputEvent& event,
blink::WebCursorInfo& cursor_info);
virtual void didReceiveResponse(const blink::WebURLResponse& response);
virtual void didReceiveData(const char* data, int data_length);
virtual void didFinishLoading();
virtual void didFailLoading(const blink::WebURLError& error);
// Called in response to WebPluginContainer::loadFrameRequest
virtual void didFinishLoadingFrameRequest(const blink::WebURL& url,
void* notifyData) {}
virtual void didFailLoadingFrameRequest(const blink::WebURL& url,
void* notify_data,
const blink::WebURLError& error) {}
// WebViewClient methods:
virtual bool acceptsLoadDrops();
virtual void setToolTipText(const blink::WebString&,
blink::WebTextDirection);
virtual void startDragging(blink::WebFrame* frame,
const blink::WebDragData& drag_data,
blink::WebDragOperationsMask mask,
const blink::WebImage& image,
const blink::WebPoint& point);
// WebWidgetClient methods:
virtual void didInvalidateRect(const blink::WebRect&);
virtual void didChangeCursor(const blink::WebCursorInfo& cursor);
// WebFrameClient methods:
virtual void didClearWindowObject(blink::WebFrame* frame);
// This method is defined in WebPlugin as well as in WebFrameClient, but with
// different parameters. We only care about implementing the WebPlugin
// version, so we implement this method and call the default in WebFrameClient
// (which does nothing) to correctly overload it.
virtual void didReceiveResponse(blink::WebFrame* frame,
unsigned identifier,
const blink::WebURLResponse& response);
private:
friend class base::DeleteHelper<WebViewPlugin>;
virtual ~WebViewPlugin();
// Manages its own lifetime.
Delegate* delegate_;
blink::WebCursorInfo current_cursor_;
// Owns us.
blink::WebPluginContainer* container_;
// Owned by us, deleted via |close()|.
blink::WebView* web_view_;
// Owned by us, deleted via |close()|.
blink::WebFrame* web_frame_;
gfx::Rect rect_;
blink::WebURLResponse response_;
std::list<std::string> data_;
bool finished_loading_;
scoped_ptr<blink::WebURLError> error_;
blink::WebString old_title_;
};
#endif // COMPONENTS_PLUGINS_RENDERER_WEBVIEW_PLUGIN_H_
|
