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
188
189
190
|
// Copyright 2014 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 EXTENSIONS_BROWSER_EXTENSION_HOST_H_
#define EXTENSIONS_BROWSER_EXTENSION_HOST_H_
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/timer/elapsed_timer.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/browser/web_contents_observer.h"
#include "extensions/browser/extension_function_dispatcher.h"
#include "extensions/common/stack_frame.h"
#include "extensions/common/view_type.h"
class PrefsTabHelper;
namespace content {
class BrowserContext;
class RenderProcessHost;
class RenderWidgetHostView;
class SiteInstance;
}
namespace extensions {
class Extension;
class ExtensionHostDelegate;
class WindowController;
// This class is the browser component of an extension component's RenderView.
// It handles setting up the renderer process, if needed, with special
// privileges available to extensions. It may have a view to be shown in the
// browser UI, or it may be hidden.
//
// If you are adding code that only affects visible extension views (and not
// invisible background pages) you should add it to ExtensionViewHost.
class ExtensionHost : public content::WebContentsDelegate,
public content::WebContentsObserver,
public ExtensionFunctionDispatcher::Delegate,
public content::NotificationObserver {
public:
class ProcessCreationQueue;
ExtensionHost(const Extension* extension,
content::SiteInstance* site_instance,
const GURL& url, ViewType host_type);
virtual ~ExtensionHost();
const Extension* extension() const { return extension_; }
const std::string& extension_id() const { return extension_id_; }
content::WebContents* host_contents() const { return host_contents_.get(); }
content::RenderViewHost* render_view_host() const;
content::RenderProcessHost* render_process_host() const;
bool did_stop_loading() const { return did_stop_loading_; }
bool document_element_available() const {
return document_element_available_;
}
content::BrowserContext* browser_context() { return browser_context_; }
ViewType extension_host_type() const { return extension_host_type_; }
const GURL& GetURL() const;
// Returns true if the render view is initialized and didn't crash.
bool IsRenderViewLive() const;
// Prepares to initializes our RenderViewHost by creating its RenderView and
// navigating to this host's url. Uses host_view for the RenderViewHost's view
// (can be NULL). This happens delayed to avoid locking the UI.
void CreateRenderViewSoon();
// content::WebContentsObserver
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
virtual void RenderViewCreated(
content::RenderViewHost* render_view_host) OVERRIDE;
virtual void RenderViewDeleted(
content::RenderViewHost* render_view_host) OVERRIDE;
virtual void RenderViewReady() OVERRIDE;
virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
virtual void DocumentAvailableInMainFrame() OVERRIDE;
virtual void DidStopLoading(
content::RenderViewHost* render_view_host) OVERRIDE;
// content::WebContentsDelegate
virtual content::JavaScriptDialogManager*
GetJavaScriptDialogManager() OVERRIDE;
virtual void AddNewContents(content::WebContents* source,
content::WebContents* new_contents,
WindowOpenDisposition disposition,
const gfx::Rect& initial_pos,
bool user_gesture,
bool* was_blocked) OVERRIDE;
virtual void CloseContents(content::WebContents* contents) OVERRIDE;
virtual void RequestMediaAccessPermission(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback) OVERRIDE;
virtual bool CheckMediaAccessPermission(
content::WebContents* web_contents,
const GURL& security_origin,
content::MediaStreamType type) OVERRIDE;
virtual bool IsNeverVisible(content::WebContents* web_contents) OVERRIDE;
// content::NotificationObserver
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
protected:
content::NotificationRegistrar* registrar() { return ®istrar_; }
// Called after the extension page finishes loading but before the
// EXTENSION_HOST_DID_STOP_LOADING notification is sent.
virtual void OnDidStopLoading();
// Called once when the document first becomes available.
virtual void OnDocumentAvailable();
// Navigates to the initial page.
virtual void LoadInitialURL();
// Returns true if we're hosting a background page.
virtual bool IsBackgroundPage() const;
// Closes this host (results in deletion).
void Close();
private:
friend class ProcessCreationQueue;
// Actually create the RenderView for this host. See CreateRenderViewSoon.
void CreateRenderViewNow();
// Message handlers.
void OnRequest(const ExtensionHostMsg_Request_Params& params);
void OnEventAck();
void OnIncrementLazyKeepaliveCount();
void OnDecrementLazyKeepaliveCount();
// Delegate for functionality that cannot exist in the extensions module.
scoped_ptr<ExtensionHostDelegate> delegate_;
// The extension that we're hosting in this view.
const Extension* extension_;
// Id of extension that we're hosting in this view.
const std::string extension_id_;
// The browser context that this host is tied to.
content::BrowserContext* browser_context_;
// The host for our HTML content.
scoped_ptr<content::WebContents> host_contents_;
// A weak pointer to the current or pending RenderViewHost. We don't access
// this through the host_contents because we want to deal with the pending
// host, so we can send messages to it before it finishes loading.
content::RenderViewHost* render_view_host_;
// Whether the RenderWidget has reported that it has stopped loading.
bool did_stop_loading_;
// True if the main frame has finished parsing.
bool document_element_available_;
// The original URL of the page being hosted.
GURL initial_url_;
content::NotificationRegistrar registrar_;
ExtensionFunctionDispatcher extension_function_dispatcher_;
// The type of view being hosted.
ViewType extension_host_type_;
// Used to measure how long it's been since the host was created.
base::ElapsedTimer since_created_;
DISALLOW_COPY_AND_ASSIGN(ExtensionHost);
};
} // namespace extensions
#endif // EXTENSIONS_BROWSER_EXTENSION_HOST_H_
|
