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

remoting/host/remoting_me2me_host.cc

 // 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 28 matching lines @@
 #include "remoting/base/service_urls.h"
 #include "remoting/base/util.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/config_file_watcher.h"
 #include "remoting/host/config_watcher.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/desktop_session_connector.h"
+#include "remoting/host/gcd_rest_client.h"
 #include "remoting/host/host_change_notification_listener.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/host_main.h"
 #include "remoting/host/host_signaling_manager.h"
 #include "remoting/host/host_status_logger.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/ipc_desktop_environment.h"
 #include "remoting/host/ipc_host_event_logger.h"
@@ skipping 207 matching lines @@
   bool OnUsernamePolicyUpdate(base::DictionaryValue* policies);
   bool OnNatPolicyUpdate(base::DictionaryValue* policies);
   bool OnRelayPolicyUpdate(base::DictionaryValue* policies);
   bool OnUdpPortPolicyUpdate(base::DictionaryValue* policies);
   bool OnCurtainPolicyUpdate(base::DictionaryValue* policies);
   bool OnHostTalkGadgetPrefixPolicyUpdate(base::DictionaryValue* policies);
   bool OnHostTokenUrlPolicyUpdate(base::DictionaryValue* policies);
   bool OnPairingPolicyUpdate(base::DictionaryValue* policies);
   bool OnGnubbyAuthPolicyUpdate(base::DictionaryValue* policies);
 
+  scoped_ptr<OAuthTokenGetter> CreateOAuthTokenGetter();
+  scoped_ptr<GcdRestClient> CreateGcdRestClient();
   scoped_ptr<HostSignalingManager> CreateHostSignalingManager();
 
   void StartHostIfReady();
   void StartHost();
 
   // Overrides for HostSignalingManager::Listener interface.
   void OnHeartbeatSuccessful() override;
   void OnUnknownHostIdError() override;
   void OnAuthFailed() override;
 
@@ skipping 12 matching lines @@
       IPC::PlatformFileForTransit unprivileged_key);
 #endif  // defined(OS_WIN)
 
   // Crashes the process in response to a daemon's request. The daemon passes
   // the location of the code that detected the fatal error resulted in this
   // request.
   void OnCrash(const std::string& function_name,
                const std::string& file_name,
                const int& line_number);
 
+  bool using_gcd() { return !gcd_device_id_.empty(); }
+
   scoped_ptr<ChromotingHostContext> context_;
 
   // Accessed on the UI thread.
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
 
   // XMPP server/remoting bot configuration (initialized from the command line).
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
 
   // Created on the UI thread but used from the network thread.
@@ skipping 32 matching lines @@
   ThirdPartyAuthConfig third_party_auth_config_;
   bool enable_gnubby_auth_;
 
   // Boolean to change flow, where necessary, if we're
   // capturing a window instead of the entire desktop.
   bool enable_window_capture_;
 
   // Used to specify which window to stream, if enabled.
   webrtc::WindowId window_id_;
 
+  scoped_ptr<OAuthTokenGetter> oauth_token_getter_;

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

Comment that this object must outlive gcd_rest_client_ and
host_signaling_manager_

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

Done.

+
+  scoped_ptr<GcdRestClient> gcd_rest_client_;
+
   // Used to send heartbeats while running, and the reason for going offline
   // when shutting down.
   scoped_ptr<HostSignalingManager> host_signaling_manager_;
 
   scoped_ptr<HostChangeNotificationListener> host_change_notification_listener_;
   scoped_ptr<HostStatusLogger> host_status_logger_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
   scoped_ptr<ChromotingHost> host_;
 
@@ skipping 924 matching lines @@
   } else {
     HOST_LOG << "Policy disables gnubby auth.";
   }
 
   if (desktop_environment_factory_)
     desktop_environment_factory_->SetEnableGnubbyAuth(enable_gnubby_auth_);
 
   return true;
 }
 
-scoped_ptr<HostSignalingManager> HostProcess::CreateHostSignalingManager() {
-  DCHECK(!host_id_.empty());  // |ApplyConfig| should already have been run.
+scoped_ptr<OAuthTokenGetter> HostProcess::CreateOAuthTokenGetter() {
+  DCHECK(context_);
 
   scoped_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials(
       new OAuthTokenGetter::OAuthCredentials(xmpp_server_config_.username,
                                              oauth_refresh_token_,
                                              use_service_account_));
 
+  return make_scoped_ptr(new OAuthTokenGetter(
+      oauth_credentials.Pass(), context_->url_request_context_getter(), false,
+      !using_gcd()));
+}
+
+scoped_ptr<GcdRestClient> HostProcess::CreateGcdRestClient() {
+  DCHECK(oauth_token_getter_);
+
+  if (!using_gcd()) {
+    return nullptr;
+  }
+
+  ServiceUrls* service_urls = ServiceUrls::GetInstance();
+  return make_scoped_ptr(new GcdRestClient(
+      service_urls->gcd_base_url(), gcd_device_id_,
+      context_->url_request_context_getter(), oauth_token_getter_.get()));
+}
+
+scoped_ptr<HostSignalingManager> HostProcess::CreateHostSignalingManager() {
+  DCHECK(!host_id_.empty());  // |ApplyConfig| should already have been run.

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

s/|ApplyConfig|/ApplyConfig()/ 
FunctionName() vs |variable_name|

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

Done.

+  DCHECK(context_);
+  DCHECK(oauth_token_getter_);
+
   return HostSignalingManager::Create(
       this, context_->url_request_context_getter(), xmpp_server_config_,
       talkgadget_prefix_, host_id_, key_pair_, directory_bot_jid_,
-      oauth_credentials.Pass(), gcd_device_id_.empty());
+      oauth_token_getter_.get(), gcd_rest_client_.get());
 }
 
 void HostProcess::StartHostIfReady() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(state_, HOST_STARTING);
 
   // Start the host if both the config and the policies are loaded.
   if (!serialized_config_.empty()) {
     if (policy_state_ == POLICY_LOADED) {
       StartHost();
     } else if (policy_state_ == POLICY_ERROR_REPORT_PENDING) {
       ReportPolicyErrorAndRestartHost();
     }
   }
 }
 
 void HostProcess::StartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!host_);
   DCHECK(!host_signaling_manager_);
+  DCHECK(!gcd_rest_client_);
 
   SetState(HOST_STARTED);
 
+  oauth_token_getter_ = CreateOAuthTokenGetter();
+  gcd_rest_client_ = CreateGcdRestClient();
   host_signaling_manager_ = CreateHostSignalingManager();
 
   uint32 network_flags = 0;
   if (allow_nat_traversal_) {
     network_flags = NetworkSettings::NAT_TRAVERSAL_STUN |
                     NetworkSettings::NAT_TRAVERSAL_OUTGOING;
     if (allow_relay_)
       network_flags |= NetworkSettings::NAT_TRAVERSAL_RELAY;
   }
 
@@ skipping 36 matching lines @@
 
   // TODO(simonmorris): Get the maximum session duration from a policy.
 #if defined(OS_LINUX)
   host_->SetMaximumSessionDuration(base::TimeDelta::FromHours(20));
 #endif
 
   host_change_notification_listener_.reset(new HostChangeNotificationListener(
       this, host_id_, host_signaling_manager_->signal_strategy(),
       directory_bot_jid_));
 
-  host_status_logger_.reset(new HostStatusLogger(
-      host_->AsWeakPtr(), ServerLogEntry::ME2ME,
-      host_signaling_manager_->signal_strategy(), directory_bot_jid_));
+  if (using_gcd()) {
+    // TODO(jrw): Implement logging for GCD hosts.
+    HOST_LOG << "Logging not implemented for GCD hosts.";
+  } else {
+    host_status_logger_.reset(new HostStatusLogger(
+        host_->AsWeakPtr(), ServerLogEntry::ME2ME,
+        host_signaling_manager_->signal_strategy(), directory_bot_jid_));
+  }
 
   // Set up reporting the host status notifications.
 #if defined(REMOTING_MULTI_PROCESS)
   host_event_logger_.reset(
       new IpcHostEventLogger(host_->AsWeakPtr(), daemon_channel_.get()));
 #else  // !defined(REMOTING_MULTI_PROCESS)
   host_event_logger_ =
       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
@@ skipping 50 matching lines @@
   // Shut down everything except the HostSignalingManager.
   host_.reset();
   host_event_logger_.reset();
   host_status_logger_.reset();
   host_change_notification_listener_.reset();
 
   // Before shutting down HostSignalingManager, send the |host_offline_reason|
   // if possible (i.e. if we have the config).
   if (!serialized_config_.empty()) {
     if (!host_signaling_manager_) {
       host_signaling_manager_ = CreateHostSignalingManager();

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

Do you need to call CreateOAuthTokenGetter() here?
I think you want to merge with trunk where I removed
CreateHostSignalingManager() and replaced it with IntializeSignaling() I suggest
moving initialization of GcdRestClient and OAuthTokenGetter inside that
function.

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

Done.

     }
 
     host_signaling_manager_->SendHostOfflineReason(
         host_offline_reason,
         base::TimeDelta::FromSeconds(kHostOfflineReasonTimeoutSeconds),
         base::Bind(&HostProcess::OnHostOfflineReasonAck, this));
     return;  // Shutdown will resume after OnHostOfflineReasonAck.
   }
 
   // Continue the shutdown without sending the host offline reason.
   HOST_LOG << "Can't send offline reason (" << host_offline_reason << ") "
            << "without a valid host config.";
   OnHostOfflineReasonAck(false);
 }
 
 void HostProcess::OnHostOfflineReasonAck(bool success) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!host_);  // Assert that the host is really offline at this point.
 
   HOST_LOG << "SendHostOfflineReason " << (success ? "succeeded." : "failed.");
   host_signaling_manager_.reset();
+  gcd_rest_client_.reset();
+  oauth_token_getter_.reset();
 
   if (state_ == HOST_GOING_OFFLINE_TO_RESTART) {
     SetState(HOST_STARTING);
     StartHostIfReady();
   } else if (state_ == HOST_GOING_OFFLINE_TO_STOP) {
     SetState(HOST_STOPPED);
 
     shutdown_watchdog_->SetExitCode(*exit_code_out_);
     shutdown_watchdog_->Arm();
 
@@ skipping 58 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(context.Pass(), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting