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
|
// Copyright (c) 2009 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_RENDERER_WEBPLUGIN_DELEGATE_PEPPER_H_
#define CHROME_RENDERER_WEBPLUGIN_DELEGATE_PEPPER_H_
#include "build/build_config.h"
#include <map>
#include <string>
#include <vector>
#include "app/gfx/native_widget_types.h"
#include "base/file_path.h"
#include "base/linked_ptr.h"
#include "base/gfx/rect.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#include "base/task.h"
#include "chrome/common/transport_dib.h"
#include "skia/ext/platform_canvas.h"
#include "third_party/npapi/bindings/npapi.h"
#include "third_party/npapi/bindings/npapi_extensions.h"
#include "webkit/glue/webcursor.h"
#include "webkit/glue/webplugin_delegate.h"
namespace NPAPI {
class PluginInstance;
}
// An implementation of WebPluginDelegate for Pepper in-process plugins.
class WebPluginDelegatePepper : public webkit_glue::WebPluginDelegate {
public:
static WebPluginDelegatePepper* Create(const FilePath& filename,
const std::string& mime_type, gfx::PluginWindowHandle containing_view);
static bool IsPluginDelegateWindow(gfx::NativeWindow window);
static bool GetPluginNameFromWindow(gfx::NativeWindow window,
std::wstring *plugin_name);
// Returns true if the window handle passed in is that of the dummy
// activation window for windowless plugins.
static bool IsDummyActivationWindow(gfx::NativeWindow window);
// WebPluginDelegate implementation
virtual bool Initialize(const GURL& url,
const std::vector<std::string>& arg_names,
const std::vector<std::string>& arg_values,
webkit_glue::WebPlugin* plugin,
bool load_manually);
virtual void PluginDestroyed();
virtual void UpdateGeometry(const gfx::Rect& window_rect,
const gfx::Rect& clip_rect);
virtual void Paint(WebKit::WebCanvas* canvas, const gfx::Rect& rect);
virtual void Print(gfx::NativeDrawingContext context);
virtual void SetFocus();
virtual bool HandleInputEvent(const WebKit::WebInputEvent& event,
WebKit::WebCursorInfo* cursor);
virtual NPObject* GetPluginScriptableObject();
virtual void DidFinishLoadWithReason(const GURL& url, NPReason reason,
intptr_t notify_data);
virtual int GetProcessId();
virtual void SendJavaScriptStream(const GURL& url,
const std::string& result,
bool success, bool notify_needed,
intptr_t notify_data);
virtual void DidReceiveManualResponse(const GURL& url,
const std::string& mime_type,
const std::string& headers,
uint32 expected_length,
uint32 last_modified);
virtual void DidReceiveManualData(const char* buffer, int length);
virtual void DidFinishManualLoading();
virtual void DidManualLoadFail();
virtual void InstallMissingPlugin();
virtual webkit_glue::WebPluginResourceClient* CreateResourceClient(
unsigned long resource_id,
const GURL& url,
bool notify_needed,
intptr_t notify_data,
intptr_t stream);
// WebPlugin2DDeviceDelegate implementation.
virtual NPError Device2DQueryCapability(int32 capability, int32* value);
virtual NPError Device2DQueryConfig(const NPDeviceContext2DConfig* request,
NPDeviceContext2DConfig* obtain);
virtual NPError Device2DInitializeContext(
const NPDeviceContext2DConfig* config,
NPDeviceContext2D* context);
virtual NPError Device2DSetStateContext(NPDeviceContext2D* context,
int32 state,
int32 value);
virtual NPError Device2DGetStateContext(NPDeviceContext2D* context,
int32 state,
int32* value);
virtual NPError Device2DFlushContext(NPP id,
NPDeviceContext2D* context,
NPDeviceFlushContextCallbackPtr callback,
void* user_data);
virtual NPError Device2DDestroyContext(NPDeviceContext2D* context);
// WebPlugin3DDeviceDelegate implementation.
virtual NPError Device3DQueryCapability(int32 capability, int32* value);
virtual NPError Device3DQueryConfig(const NPDeviceContext3DConfig* request,
NPDeviceContext3DConfig* obtain);
virtual NPError Device3DInitializeContext(
const NPDeviceContext3DConfig* config,
NPDeviceContext3D* context);
virtual NPError Device3DSetStateContext(NPDeviceContext3D* context,
int32 state,
int32 value);
virtual NPError Device3DGetStateContext(NPDeviceContext3D* context,
int32 state,
int32* value);
virtual NPError Device3DFlushContext(NPP id,
NPDeviceContext3D* context,
NPDeviceFlushContextCallbackPtr callback,
void* user_data);
virtual NPError Device3DDestroyContext(NPDeviceContext3D* context);
// End of WebPluginDelegate implementation.
bool IsWindowless() const { return true; }
gfx::Rect GetRect() const { return window_rect_; }
gfx::Rect GetClipRect() const { return clip_rect_; }
// Returns the path for the library implementing this plugin.
FilePath GetPluginPath();
private:
WebPluginDelegatePepper(gfx::PluginWindowHandle containing_view,
NPAPI::PluginInstance *instance);
~WebPluginDelegatePepper();
// Tells the plugin about the current state of the window.
// See NPAPI NPP_SetWindow for more information.
void WindowlessSetWindow(bool force_set_window);
//-----------------------------------------
// used for windowed and windowless plugins
NPAPI::PluginInstance* instance() { return instance_.get(); }
// Closes down and destroys our plugin instance.
void DestroyInstance();
webkit_glue::WebPlugin* plugin_;
scoped_refptr<NPAPI::PluginInstance> instance_;
gfx::PluginWindowHandle parent_;
NPWindow window_;
gfx::Rect window_rect_;
gfx::Rect clip_rect_;
std::vector<gfx::Rect> cutout_rects_;
// Plugin graphics context implementation
size_t buffer_size_;
TransportDIB* plugin_buffer_;
static uint32 next_buffer_id;
SkBitmap committed_bitmap_;
// Lists all contexts currently open for painting. These are ones requested by
// the plugin but not destroyed by it yet. The source pointer is the raw
// pixels. We use this to look up the corresponding transport DIB when the
// plugin tells us to flush or destroy it.
struct OpenPaintContext {
scoped_ptr<TransportDIB> transport_dib;
// The canvas associated with the transport DIB, containing the mapped
// memory of the image.
scoped_ptr<skia::PlatformCanvas> canvas;
};
typedef std::map< void*, linked_ptr<OpenPaintContext> > OpenPaintContextMap;
OpenPaintContextMap open_paint_contexts_;
// The url with which the plugin was instantiated.
std::string plugin_url_;
DISALLOW_COPY_AND_ASSIGN(WebPluginDelegatePepper);
};
#endif // CHROME_RENDERER_WEBPLUGIN_DELEGATE_PEPPER_H_
|
