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
|
// 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 <list>
#include <string>
#include <vector>
#include "app/gfx/native_widget_types.h"
#include "base/file_path.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 "webkit/glue/pepper/pepper.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(
int resource_id,
const GURL& url,
bool notify_needed,
intptr_t notify_data,
intptr_t stream);
// 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();
//----------------------------
// used for windowless plugins
virtual NPError InitializeRenderContext(NPRenderType type,
NPRenderContext* context);
virtual NPError FlushRenderContext(NPRenderContext* context);
virtual NPError OpenFileInSandbox(const char* file_name, void** handle);
// 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;
scoped_ptr<skia::PlatformCanvas> plugin_canvas_;
SkBitmap committed_bitmap_;
// The url with which the plugin was instantiated.
std::string plugin_url_;
DISALLOW_COPY_AND_ASSIGN(WebPluginDelegatePepper);
};
#endif // CHROME_RENDERER_WEBPLUGIN_DELEGATE_PEPPER_H_
|
