Updated remoting host to create instances of GCD-related classes.

remoting/host/host_signaling_manager.cc

 // 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.
 
 #include "remoting/host/host_signaling_manager.h"
 
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/dns_blackhole_checker.h"
+#include "remoting/host/gcd_notification_subscriber.h"
+#include "remoting/host/gcd_state_updater.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace remoting {
 
 HostSignalingManager::HostSignalingManager(
     scoped_ptr<SignalStrategy> signal_strategy,
     scoped_ptr<SignalingConnector> signaling_connector,
-    scoped_ptr<HeartbeatSender> heartbeat_sender)
+    scoped_ptr<HeartbeatSender> heartbeat_sender,
+    scoped_ptr<GcdStateUpdater> gcd_state_updater,
+    scoped_ptr<GcdNotificationSubscriber> gcd_subscriber)
     : signal_strategy_(signal_strategy.Pass()),
       signaling_connector_(signaling_connector.Pass()),
-      heartbeat_sender_(heartbeat_sender.Pass()) {
+      heartbeat_sender_(heartbeat_sender.Pass()),
+      gcd_state_updater_(gcd_state_updater.Pass()),
+      gcd_subscriber_(gcd_subscriber.Pass()) {
 }
 
 scoped_ptr<HostSignalingManager> HostSignalingManager::Create(
     Listener* listener,
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& talkgadget_prefix_policy,
     const std::string& host_id,
     const scoped_refptr<const RsaKeyPair>& host_key_pair,
     const std::string& directory_bot_jid,
-    scoped_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials,
-    bool verify_email) {
+    OAuthTokenGetter* oauth_token_getter,
+    GcdRestClient* gcd_rest_client) {
   scoped_ptr<XmppSignalStrategy> signal_strategy(
       new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                              url_request_context_getter, xmpp_server_config));
 
   scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(new DnsBlackholeChecker(
       url_request_context_getter, talkgadget_prefix_policy));
-  scoped_ptr<OAuthTokenGetter> oauth_token_getter(
-      new OAuthTokenGetter(oauth_credentials.Pass(), url_request_context_getter,
-                           false, verify_email));
 
   scoped_ptr<SignalingConnector> signaling_connector(new SignalingConnector(
-      signal_strategy.get(), dns_blackhole_checker.Pass(),
-      oauth_token_getter.Pass(),
+      signal_strategy.get(), dns_blackhole_checker.Pass(), oauth_token_getter,
       base::Bind(&Listener::OnAuthFailed, base::Unretained(listener))));
 
-  scoped_ptr<HeartbeatSender> heartbeat_sender(new HeartbeatSender(
-      base::Bind(&Listener::OnHeartbeatSuccessful, base::Unretained(listener)),
-      base::Bind(&Listener::OnUnknownHostIdError, base::Unretained(listener)),
-      host_id, signal_strategy.get(), host_key_pair, directory_bot_jid));
+  scoped_ptr<GcdStateUpdater> gcd_state_updater;
+  scoped_ptr<GcdNotificationSubscriber> gcd_subscriber;
+  scoped_ptr<HeartbeatSender> heartbeat_sender;
+
+  if (gcd_rest_client) {
+    gcd_state_updater.reset(
+        new GcdStateUpdater(base::Bind(&Listener::OnHeartbeatSuccessful,
+                                       base::Unretained(listener)),
+                            signal_strategy.get(), gcd_rest_client));
+    gcd_subscriber.reset(new GcdNotificationSubscriber(signal_strategy.get()));
+  } else {
+    heartbeat_sender.reset(new HeartbeatSender(
+        base::Bind(&Listener::OnHeartbeatSuccessful,
+                   base::Unretained(listener)),
+        base::Bind(&Listener::OnUnknownHostIdError, base::Unretained(listener)),
+        host_id, signal_strategy.get(), host_key_pair, directory_bot_jid));
+  }
 
   return scoped_ptr<HostSignalingManager>(new HostSignalingManager(
       signal_strategy.Pass(), signaling_connector.Pass(),
-      heartbeat_sender.Pass()));
+      heartbeat_sender.Pass(), gcd_state_updater.Pass(),
+      gcd_subscriber.Pass()));
 }
 
 HostSignalingManager::~HostSignalingManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void HostSignalingManager::SendHostOfflineReason(
     const std::string& host_offline_reason,
     const base::TimeDelta& timeout,
     const base::Callback<void(bool success)>& ack_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   HOST_LOG << "SendHostOfflineReason: sending " << host_offline_reason << ".";
-  heartbeat_sender_->SetHostOfflineReason(host_offline_reason, timeout,
-                                          ack_callback);
+  if (heartbeat_sender_) {
+    heartbeat_sender_->SetHostOfflineReason(host_offline_reason, timeout,
+                                            ack_callback);
+  }
+  if (gcd_state_updater_) {
+    gcd_state_updater_->SetHostOfflineReason(host_offline_reason, timeout,
+                                             ack_callback);
+  }
 }
 
 }  // namespace remoting