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
|
// 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_RENDERER_STARTUP_HELPER_H_
#define EXTENSIONS_BROWSER_RENDERER_STARTUP_HELPER_H_
#include <map>
#include <set>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/singleton.h"
#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
#include "components/keyed_service/core/keyed_service.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "extensions/common/extension_id.h"
namespace content {
class BrowserContext;
class RenderProcessHost;
}
namespace extensions {
class Extension;
// Informs renderers about extensions-related data (loaded extensions, available
// functions, etc.) when they start. Sends this information to both extension
// and non-extension renderers, as the non-extension renderers may have content
// scripts. Lives on the UI thread. Shared between incognito and non-incognito
// browser contexts. Also handles sending the loaded, unloaded, and activated
// extension messages, since these can *only* be sent once the process is
// initialized.
// TODO(devlin): "StartupHelper" is no longer sufficient to describe the entire
// behavior of this class.
class RendererStartupHelper : public KeyedService,
public content::NotificationObserver {
public:
// This class sends messages to all renderers started for |browser_context|.
explicit RendererStartupHelper(content::BrowserContext* browser_context);
~RendererStartupHelper() override;
// content::NotificationObserver overrides:
void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) override;
// Sends a message to the specified |process| activating the given extension
// once the process is initialized.
void ActivateExtensionInProcess(const Extension& extension,
content::RenderProcessHost* process);
// Sends a message to all initialized processes to [un]load the given
// extension. We have explicit calls for these (rather than using an
// ExtensionRegistryObserver) because this needs to happen before other
// initialization which might rely on the renderers being notified.
void OnExtensionUnloaded(const Extension& extension);
void OnExtensionLoaded(const Extension& extension);
private:
// Initializes the specified process, informing it of system state and loaded
// extensions.
void InitializeProcess(content::RenderProcessHost* process);
// Untracks the given process.
void UntrackProcess(content::RenderProcessHost* process);
content::BrowserContext* browser_context_; // Not owned.
// The set of render processes that have had the initial batch of IPC messages
// sent, including the set of loaded extensions. Further messages that
// activate, load, or unload extensions should not be sent until after this
// happens.
std::set<content::RenderProcessHost*> initialized_processes_;
// The set of ids for extensions that are active in a process that has not
// been initialized. The activation message will be sent the process is
// initialized.
std::map<content::RenderProcessHost*, std::set<ExtensionId>>
pending_active_extensions_;
content::NotificationRegistrar registrar_;
DISALLOW_COPY_AND_ASSIGN(RendererStartupHelper);
};
// Factory for RendererStartupHelpers. Declared here because this header is
// rarely included and it's probably cheaper to put it here than to make the
// compiler generate another object file.
class RendererStartupHelperFactory : public BrowserContextKeyedServiceFactory {
public:
static RendererStartupHelper* GetForBrowserContext(
content::BrowserContext* context);
static RendererStartupHelperFactory* GetInstance();
private:
friend struct base::DefaultSingletonTraits<RendererStartupHelperFactory>;
RendererStartupHelperFactory();
~RendererStartupHelperFactory() override;
// BrowserContextKeyedServiceFactory implementation:
KeyedService* BuildServiceInstanceFor(
content::BrowserContext* profile) const override;
content::BrowserContext* GetBrowserContextToUse(
content::BrowserContext* context) const override;
bool ServiceIsCreatedWithBrowserContext() const override;
DISALLOW_COPY_AND_ASSIGN(RendererStartupHelperFactory);
};
} // namespace extensions
#endif // EXTENSIONS_BROWSER_RENDERER_STARTUP_HELPER_H_
|
