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
|
// Copyright (c) 2012 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.
#include "chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h"
#include "base/lazy_instance.h"
#include "chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.h"
#include "chrome/browser/sync_file_system/sync_event_observer.h"
#include "chrome/browser/sync_file_system/sync_file_system_service.h"
#include "chrome/browser/sync_file_system/sync_file_system_service_factory.h"
#include "chrome/browser/sync_file_system/syncable_file_system_util.h"
#include "chrome/common/extensions/api/sync_file_system.h"
#include "content/public/browser/browser_context.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_system_provider.h"
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/common/extension_set.h"
#include "storage/browser/fileapi/file_system_url.h"
#include "storage/common/fileapi/file_system_util.h"
using sync_file_system::SyncEventObserver;
namespace extensions {
static base::LazyInstance<
BrowserContextKeyedAPIFactory<ExtensionSyncEventObserver> > g_factory =
LAZY_INSTANCE_INITIALIZER;
// static
BrowserContextKeyedAPIFactory<ExtensionSyncEventObserver>*
ExtensionSyncEventObserver::GetFactoryInstance() {
return g_factory.Pointer();
}
ExtensionSyncEventObserver::ExtensionSyncEventObserver(
content::BrowserContext* context)
: browser_context_(context), sync_service_(NULL) {}
void ExtensionSyncEventObserver::InitializeForService(
sync_file_system::SyncFileSystemService* sync_service) {
DCHECK(sync_service);
if (sync_service_ != NULL) {
DCHECK_EQ(sync_service_, sync_service);
return;
}
sync_service_ = sync_service;
sync_service_->AddSyncEventObserver(this);
}
ExtensionSyncEventObserver::~ExtensionSyncEventObserver() {}
void ExtensionSyncEventObserver::Shutdown() {
if (sync_service_ != NULL)
sync_service_->RemoveSyncEventObserver(this);
}
std::string ExtensionSyncEventObserver::GetExtensionId(
const GURL& app_origin) {
const Extension* app = ExtensionRegistry::Get(browser_context_)
->enabled_extensions().GetAppByURL(app_origin);
if (!app) {
// The app is uninstalled or disabled.
return std::string();
}
return app->id();
}
void ExtensionSyncEventObserver::OnSyncStateUpdated(
const GURL& app_origin,
sync_file_system::SyncServiceState state,
const std::string& description) {
// Convert state and description into SyncState Object.
api::sync_file_system::ServiceInfo service_info;
service_info.state = SyncServiceStateToExtensionEnum(state);
service_info.description = description;
scoped_ptr<base::ListValue> params(
api::sync_file_system::OnServiceStatusChanged::Create(service_info));
BroadcastOrDispatchEvent(
app_origin,
api::sync_file_system::OnServiceStatusChanged::kEventName,
params.Pass());
}
void ExtensionSyncEventObserver::OnFileSynced(
const storage::FileSystemURL& url,
sync_file_system::SyncFileType file_type,
sync_file_system::SyncFileStatus status,
sync_file_system::SyncAction action,
sync_file_system::SyncDirection direction) {
scoped_ptr<base::ListValue> params(new base::ListValue());
scoped_ptr<base::DictionaryValue> entry(
CreateDictionaryValueForFileSystemEntry(url, file_type));
if (!entry)
return;
params->Append(entry.release());
// Status, SyncAction and any optional notes to go here.
api::sync_file_system::FileStatus status_enum =
SyncFileStatusToExtensionEnum(status);
api::sync_file_system::SyncAction action_enum =
SyncActionToExtensionEnum(action);
api::sync_file_system::SyncDirection direction_enum =
SyncDirectionToExtensionEnum(direction);
params->AppendString(api::sync_file_system::ToString(status_enum));
params->AppendString(api::sync_file_system::ToString(action_enum));
params->AppendString(api::sync_file_system::ToString(direction_enum));
BroadcastOrDispatchEvent(
url.origin(),
api::sync_file_system::OnFileStatusChanged::kEventName,
params.Pass());
}
void ExtensionSyncEventObserver::BroadcastOrDispatchEvent(
const GURL& app_origin,
const std::string& event_name,
scoped_ptr<base::ListValue> values) {
// Check to see whether the event should be broadcasted to all listening
// extensions or sent to a specific extension ID.
bool broadcast_mode = app_origin.is_empty();
EventRouter* event_router = EventRouter::Get(browser_context_);
DCHECK(event_router);
scoped_ptr<Event> event(new Event(event_name, values.Pass()));
event->restrict_to_browser_context = browser_context_;
// No app_origin, broadcast to all listening extensions for this event name.
if (broadcast_mode) {
event_router->BroadcastEvent(event.Pass());
return;
}
// Dispatch to single extension ID.
const std::string extension_id = GetExtensionId(app_origin);
if (extension_id.empty())
return;
event_router->DispatchEventToExtension(extension_id, event.Pass());
}
template <>
void BrowserContextKeyedAPIFactory<
ExtensionSyncEventObserver>::DeclareFactoryDependencies() {
DependsOn(sync_file_system::SyncFileSystemServiceFactory::GetInstance());
DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
}
} // namespace extensions
|
