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
|
// Copyright (c) 2010 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_
#pragma once
#include <string>
#include "base/basictypes.h"
#include "base/file_path.h"
#include "base/hash_tables.h"
#include "base/singleton.h"
#include "base/waitable_event_watcher.h"
#include "chrome/common/notification_observer.h"
#include "chrome/common/notification_registrar.h"
#include "googleurl/src/gurl.h"
#if defined(OS_WIN)
#include "base/scoped_ptr.h"
#include "base/win/registry.h"
#endif
#if defined(OS_CHROMEOS)
namespace chromeos {
class PluginSelectionPolicy;
}
#endif
namespace IPC {
class Message;
}
class MessageLoop;
class PluginProcessHost;
class Profile;
class ResourceDispatcherHost;
class ResourceMessageFilter;
class URLRequestContext;
struct WebPluginInfo;
// 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:
// Initializes the global instance; should be called on startup from the main
// thread.
static void InitGlobalInstance(Profile* profile);
// 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::string& 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,
IPC::Message* reply_msg);
// Gets the first allowed plugin in the list of plugins that matches
// the given url and mime type. Must be called on the FILE thread.
bool GetFirstAllowedPluginInfo(const GURL& url,
const std::string& mime_type,
WebPluginInfo* info,
std::string* actual_mime_type);
// Returns true if the given plugin is allowed to be used by a page with
// the given URL.
bool PrivatePluginAllowedForURL(const FilePath& plugin_path, const GURL& url);
// 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);
void RegisterPepperPlugins();
// Helper so we can do the plugin lookup on the FILE thread.
void GetAllowedPluginForOpenChannelToPlugin(
ResourceMessageFilter* renderer_msg_filter,
const GURL& url,
const std::string& mime_type,
IPC::Message* reply_msg);
// Helper so we can finish opening the channel after looking up the
// plugin.
void FinishOpenChannelToPlugin(
ResourceMessageFilter* renderer_msg_filter,
const std::string& mime_type,
const FilePath& plugin_path,
IPC::Message* reply_msg);
// 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::string 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_CHROMEOS)
scoped_refptr<chromeos::PluginSelectionPolicy> plugin_selection_policy_;
#endif
#if defined(OS_WIN)
// Registry keys for getting notifications when new plugins are installed.
base::win::RegKey hkcu_key_;
base::win::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);
};
DISABLE_RUNNABLE_METHOD_REFCOUNT(PluginService);
#endif // CHROME_BROWSER_PLUGIN_SERVICE_H_
|
