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

remoting/host/host_signaling_manager.h

 // 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 REMOTING_HOST_HOST_SIGNALING_MANAGER_H_
 #define REMOTING_HOST_HOST_SIGNALING_MANAGER_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/host/oauth_token_getter.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace base {
 class TimeDelta;
 }
 
 namespace remoting {
 
+class GcdNotificationSubscriber;
+class GcdRestClient;
+class GcdStateUpdater;
 class HeartbeatSender;
 class OAuthTokenGetter;
 class SignalStrategy;
 class SignalingConnector;
 
 // HostSignalingManager manages objects needed for sending regular heartbeats to
 // the Chromoting Directory.
 class HostSignalingManager {

[Sergey Ulanov, 2015/05/07 21:49:55]

This class doesn't exist anymore. Please sync with trunk

[John Williams, 2015/05/20 00:22:44]

Done.

  public:
   class Listener {
    public:
     virtual ~Listener() {}
 
     // Invoked after the first successful heartbeat.
     virtual void OnHeartbeatSuccessful() = 0;
 
     // Invoked when the host ID is permanently not recognized by the server.
     virtual void OnUnknownHostIdError() = 0;
@@ skipping 10 matching lines @@
   // destroyed.
   static scoped_ptr<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_client_);
 
   ~HostSignalingManager();
 
   // Get the SignalStrategy to use for talking to the Chromoting bot.
   // Returned SignalStrategy remains owned by the HostSignalingManager.
   SignalStrategy* signal_strategy() { return signal_strategy_.get(); }
 
   // Kicks off sending a heartbeat containing a host-offline-reason attribute.
   // Will call |ack_callback| once either the bot acks receiving the
   // |host_offline_reason|, or the |timeout| is reached.
   //
   // For discussion of allowed values for |host_offline_reason| argument,
   // please see the description of rem:host-offline-reason xml attribute in
   // the class-level comments for HeartbeatReasonSender.
   void SendHostOfflineReason(
       const std::string& host_offline_reason,
       const base::TimeDelta& timeout,
       const base::Callback<void(bool success)>& ack_callback);
 
  private:
-  HostSignalingManager(
-      scoped_ptr<SignalStrategy> signal_strategy,
-      scoped_ptr<SignalingConnector> signaling_connector,
-      scoped_ptr<HeartbeatSender> heartbeat_sender);
+  HostSignalingManager(scoped_ptr<SignalStrategy> signal_strategy,
+                       scoped_ptr<SignalingConnector> signaling_connector,
+                       scoped_ptr<HeartbeatSender> heartbeat_sender,
+                       scoped_ptr<GcdStateUpdater> gcd_state_updater,
+                       scoped_ptr<GcdNotificationSubscriber> gcd_subscriber);
 
   // |heartbeat_sender_| and |signaling_connector_| have to be destroyed before
   // |signal_strategy_| because their destructors need to call
   // signal_strategy_->RemoveListener(this)
   scoped_ptr<SignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
+  scoped_ptr<GcdStateUpdater> gcd_state_updater_;
+  scoped_ptr<GcdNotificationSubscriber> gcd_subscriber_;
 
   // Used to verify thread-safe usage.
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(HostSignalingManager);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_HOST_SIGNALING_MANAGER_H_