blob: a3b8cdce0a2dca438c860b965d70c7f8d0604a37 (
plain)
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
|
// 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.
#ifndef CHROME_SERVICE_SERVICE_PROCESS_H_
#define CHROME_SERVICE_SERVICE_PROCESS_H_
#pragma once
#include <string>
#include "base/gtest_prod_util.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#include "base/threading/thread.h"
#include "base/synchronization/waitable_event.h"
#include "chrome/service/cloud_print/cloud_print_proxy.h"
#include "chrome/service/remoting/chromoting_host_manager.h"
class ServiceProcessPrefs;
class ServiceIPCServer;
class CommandLine;
class ServiceURLRequestContextGetter;
namespace net {
class NetworkChangeNotifier;
}
class CommandLine;
// The ServiceProcess does not inherit from ChildProcess because this
// process can live independently of the browser process.
class ServiceProcess : public CloudPrintProxy::Client,
public remoting::ChromotingHostManager::Observer {
public:
ServiceProcess();
~ServiceProcess();
// Initialize the ServiceProcess with the message loop that it should run on.
bool Initialize(MessageLoopForUI* message_loop,
const CommandLine& command_line);
bool Teardown();
// TODO(sanjeevr): Change various parts of the code such as
// net::ProxyService::CreateSystemProxyConfigService to take in
// MessageLoopProxy* instead of MessageLoop*. When we have done that, we can
// remove the io_thread() and file_thread() accessors and replace them with
// io_message_loop_proxy() and file_message_loop_proxy() respectively.
// Returns the thread that we perform I/O coordination on (network requests,
// communication with renderers, etc.
// NOTE: You should ONLY use this to pass to IPC or other objects which must
// need a MessageLoop*. If you just want to post a task, use the thread's
// message_loop_proxy() as it takes care of checking that a thread is still
// alive, race conditions, lifetime differences etc.
// If you still must use this, need to check the return value for NULL.
base::Thread* io_thread() const {
return io_thread_.get();
}
// Returns the thread that we perform random file operations on. For code
// that wants to do I/O operations (not network requests or even file: URL
// requests), this is the thread to use to avoid blocking the UI thread.
base::Thread* file_thread() const {
return file_thread_.get();
}
// A global event object that is signalled when the main thread's message
// loop exits. This gives background threads a way to observe the main
// thread shutting down.
base::WaitableEvent* shutdown_event() {
return &shutdown_event_;
}
// Shutdown the service process. This is likely triggered by a IPC message.
void Shutdown();
void SetUpdateAvailable() {
update_available_ = true;
}
bool update_available() const { return update_available_; }
// Called by the IPC server when a client disconnects. A return value of
// true indicates that the IPC server should continue listening for new
// connections.
bool HandleClientDisconnect();
CloudPrintProxy* GetCloudPrintProxy();
// CloudPrintProxy::Client implementation.
virtual void OnCloudPrintProxyEnabled(bool persist_state);
virtual void OnCloudPrintProxyDisabled(bool persist_state);
// ChromotingHostManager::Observer interface.
virtual void OnChromotingHostEnabled();
virtual void OnChromotingHostDisabled();
#if defined(ENABLE_REMOTING)
// Return the reference to the chromoting host only if it has started.
remoting::ChromotingHostManager* remoting_host_manager() {
return remoting_host_manager_;
}
#endif
ServiceURLRequestContextGetter* GetServiceURLRequestContextGetter();
private:
// Schedule a call to ShutdownIfNeeded.
void ScheduleShutdownCheck();
// Shuts down the process if no services are enabled and no clients are
// connected.
void ShutdownIfNeeded();
// Called exactly ONCE per process instance for each service that gets
// enabled in this process.
void OnServiceEnabled();
// Called exactly ONCE per process instance for each service that gets
// disabled in this process (note that shutdown != disabled).
void OnServiceDisabled();
scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
scoped_ptr<base::Thread> io_thread_;
scoped_ptr<base::Thread> file_thread_;
scoped_ptr<CloudPrintProxy> cloud_print_proxy_;
scoped_ptr<ServiceProcessPrefs> service_prefs_;
scoped_ptr<ServiceIPCServer> ipc_server_;
// An event that will be signalled when we shutdown.
base::WaitableEvent shutdown_event_;
// Pointer to the main message loop that host this object.
MessageLoop* main_message_loop_;
// Count of currently enabled services in this process.
int enabled_services_;
// Speficies whether a product update is available.
bool update_available_;
scoped_refptr<ServiceURLRequestContextGetter> request_context_getter_;
#if defined(ENABLE_REMOTING)
scoped_refptr<remoting::ChromotingHostManager> remoting_host_manager_;
#endif
DISALLOW_COPY_AND_ASSIGN(ServiceProcess);
};
extern ServiceProcess* g_service_process;
#endif // CHROME_SERVICE_SERVICE_PROCESS_H_
|
