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
|
// Copyright (c) 2006-2008 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.
// This class responds to requests from renderers for the list of plugins, and
// also a proxy object for plugin instances.
#ifndef CHROME_BROWSER_PLUGIN_SERVICE_H_
#define CHROME_BROWSER_PLUGIN_SERVICE_H_
#include <vector>
#include "base/basictypes.h"
#include "base/hash_tables.h"
#include "base/ref_counted.h"
#include "base/singleton.h"
#include "base/waitable_event_watcher.h"
#include "chrome/browser/browser_process.h"
#include "chrome/common/notification_observer.h"
#include "chrome/common/notification_registrar.h"
#include "googleurl/src/gurl.h"
#include "webkit/glue/webplugininfo.h"
#if defined(OS_WIN)
#include "base/registry.h"
#endif
namespace IPC {
class Message;
}
class MessageLoop;
class PluginProcessHost;
class URLRequestContext;
class ResourceDispatcherHost;
class ResourceMessageFilter;
// This must be created on the main thread but it's only called on the IO/file
// thread.
class PluginService
: public base::WaitableEventWatcher::Delegate,
public NotificationObserver {
public:
// Returns the PluginService singleton.
static PluginService* GetInstance();
// Load all the plugins that should be loaded for the lifetime of the browser
// (ie, with the LoadOnStartup flag set).
void LoadChromePlugins(ResourceDispatcherHost* resource_dispatcher_host);
// Sets/gets the data directory that Chrome plugins should use to store
// persistent data.
void SetChromePluginDataDir(const FilePath& data_dir);
const FilePath& GetChromePluginDataDir();
// Gets the browser's UI locale.
const std::wstring& GetUILocale();
// Returns the plugin process host corresponding to the plugin process that
// has been started by this service. Returns NULL if no process has been
// started.
PluginProcessHost* FindPluginProcess(const FilePath& plugin_path);
// Returns the plugin process host corresponding to the plugin process that
// has been started by this service. This will start a process to host the
// 'plugin_path' if needed. If the process fails to start, the return value
// is NULL. Must be called on the IO thread.
PluginProcessHost* FindOrStartPluginProcess(const FilePath& plugin_path);
// Opens a channel to a plugin process for the given mime type, starting
// a new plugin process if necessary. This must be called on the IO thread
// or else a deadlock can occur.
void OpenChannelToPlugin(ResourceMessageFilter* renderer_msg_filter,
const GURL& url,
const std::string& mime_type,
const std::wstring& locale,
IPC::Message* reply_msg);
// Get the path to the plugin specified. policy_url is the URL of the page
// requesting the plugin, so we can verify whether the plugin is allowed
// on that page.
FilePath GetPluginPath(const GURL& url,
const GURL& policy_url,
const std::string& mime_type,
std::string* actual_mime_type);
// The UI thread's message loop
MessageLoop* main_message_loop() { return main_message_loop_; }
ResourceDispatcherHost* resource_dispatcher_host() const {
return resource_dispatcher_host_;
}
static void EnableChromePlugins(bool enable);
private:
friend struct DefaultSingletonTraits<PluginService>;
// Creates the PluginService object, but doesn't actually build the plugin
// list yet. It's generated lazily.
PluginService();
~PluginService();
// base::WaitableEventWatcher::Delegate implementation.
virtual void OnWaitableEventSignaled(base::WaitableEvent* waitable_event);
// NotificationObserver implementation
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
// Returns true if the given plugin is allowed to be used by a page with
// the given URL.
bool PluginAllowedForURL(const FilePath& plugin_path, const GURL& url);
// mapping between plugin path and PluginProcessHost
typedef base::hash_map<FilePath, PluginProcessHost*> PluginMap;
PluginMap plugin_hosts_;
// The main thread's message loop.
MessageLoop* main_message_loop_;
// The IO thread's resource dispatcher host.
ResourceDispatcherHost* resource_dispatcher_host_;
// The data directory that Chrome plugins should use to store persistent data.
FilePath chrome_plugin_data_dir_;
// The browser's UI locale.
const std::wstring ui_locale_;
// Map of plugin paths to the origin they are restricted to. Used for
// extension-only plugins.
typedef base::hash_map<FilePath, GURL> PrivatePluginMap;
PrivatePluginMap private_plugins_;
NotificationRegistrar registrar_;
#if defined(OS_WIN)
// Registry keys for getting notifications when new plugins are installed.
RegKey hkcu_key_;
RegKey hklm_key_;
scoped_ptr<base::WaitableEvent> hkcu_event_;
scoped_ptr<base::WaitableEvent> hklm_event_;
base::WaitableEventWatcher hkcu_watcher_;
base::WaitableEventWatcher hklm_watcher_;
#endif
// Set to true if chrome plugins are enabled. Defaults to true.
static bool enable_chrome_plugins_;
DISALLOW_COPY_AND_ASSIGN(PluginService);
};
#endif // CHROME_BROWSER_PLUGIN_SERVICE_H_
|
