Remove the need to have separate config for authentication.

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 10 matching lines @@
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
-#include "remoting/host/constants.h"
-#include "remoting/host/video_frame_capturer.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
+#include "remoting/host/composite_host_config.h"
+#include "remoting/host/constants.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/host_user_interface.h"
-#include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/usage_stats_consent.h"
+#include "remoting/host/video_frame_capturer.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "remoting/host/sighup_listener_mac.h"
 #endif
 // N.B. OS_WIN is defined by including src/base headers.
 #if defined(OS_WIN)
 #include <commctrl.h>
 #endif
 #if defined(TOOLKIT_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
 // These are used for parsing the config-file locations from the command line,
 // and for defining the default locations if the switches are not present.
 const char kAuthConfigSwitchName[] = "auth-config";
 const char kHostConfigSwitchName[] = "host-config";
 
-const FilePath::CharType kDefaultAuthConfigFile[] =
-    FILE_PATH_LITERAL("auth.json");
 const FilePath::CharType kDefaultHostConfigFile[] =
     FILE_PATH_LITERAL("host.json");
 
 const int kMinPortNumber = 12400;
 const int kMaxPortNumber = 12409;
 
 const char kUnofficialOAuth2ClientId[] =
     "440925447803-2pi3v45bff6tp1rde2f7q6lgbor3o5uj.apps.googleusercontent.com";
 const char kUnofficialOAuth2ClientSecret[] = "W2ieEsG-R1gIA4MMurGrgMc_";
 
@@ skipping 21 matching lines @@
         exit_code_(kSuccessExitCode) {
     context_.reset(
         new ChromotingHostContext(message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     config_updated_timer_.reset(new base::DelayTimer<HostProcess>(
         FROM_HERE, base::TimeDelta::FromSeconds(2), this,
         &HostProcess::ConfigUpdatedDelayed));
   }
 
-  void InitWithCommandLine(const CommandLine* cmd_line) {
+  bool InitWithCommandLine(const CommandLine* cmd_line) {
     FilePath default_config_dir = remoting::GetConfigDir();
     if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
-      auth_config_path_ = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
-    } else {
-      auth_config_path_ = default_config_dir.Append(kDefaultAuthConfigFile);
+      FilePath path = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
+      if (!config_.AddConfigPath(path)) {
+        return false;
+      }
     }
 
+    FilePath config_path = default_config_dir.Append(kDefaultHostConfigFile);
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
-      host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
-    } else {
-      host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
+      config_path = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
+    }
+    if (!config_.AddConfigPath(config_path)) {
+      return false;
     }
 
-#if defined(OS_LINUX)
-    VideoFrameCapturer::EnableXDamage(true);
-#endif
+    return true;
   }
 
   void ConfigUpdated() {
     // The timer should be set and cleaned up on the same thread.
     DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
 
     // Call ConfigUpdatedDelayed after a short delay, so that this object won't
     // try to read the updated configuration file before it has been
     // completely written.
     // If the writer moves the new configuration file into place atomically,
@@ skipping 99 matching lines @@
   }
 
  private:
   void StartWatchingPolicy() {
     policy_watcher_.reset(
         policy_hack::PolicyWatcher::Create(context_->file_task_runner()));
     policy_watcher_->StartWatching(
         base::Bind(&HostProcess::OnPolicyUpdate, base::Unretained(this)));
   }
 
   // Read Host config from disk, returning true if successful.

[Lambros, 2012/08/01 01:12:48]

Remove "from disk" from this comment? Looks like the actual disk-reading has
been moved out of here into InitWithCommandLine().

[Sergey Ulanov, 2012/08/01 01:19:11]

Done.

   bool LoadConfig() {
-    JsonHostConfig host_config(host_config_path_);
-    JsonHostConfig auth_config(auth_config_path_);
-
-    FilePath failed_path;
-    if (!host_config.Read()) {
-      failed_path = host_config_path_;
-    } else if (!auth_config.Read()) {
-      failed_path = auth_config_path_;
-    }
-    if (!failed_path.empty()) {
-      LOG(ERROR) << "Failed to read configuration file " << failed_path.value();
-      return false;
-    }
-
-    if (!host_config.GetString(kHostIdConfigPath, &host_id_)) {
+    if (!config_.GetString(kHostIdConfigPath, &host_id_)) {
       LOG(ERROR) << "host_id is not defined in the config.";
       return false;
     }
 
-    if (!key_pair_.Load(host_config)) {
+    if (!key_pair_.Load(config_)) {
       return false;
     }
 
     std::string host_secret_hash_string;
-    if (!host_config.GetString(kHostSecretHashConfigPath,
-                               &host_secret_hash_string)) {
+    if (!config_.GetString(kHostSecretHashConfigPath,
+                           &host_secret_hash_string)) {
       host_secret_hash_string = "plain:";
     }
 
     if (!host_secret_hash_.Parse(host_secret_hash_string)) {
       LOG(ERROR) << "Invalid host_secret_hash.";
       return false;
     }
 
     // Use an XMPP connection to the Talk network for session signalling.
-    if (!auth_config.GetString(kXmppLoginConfigPath, &xmpp_login_) ||
-        !(auth_config.GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token_) ||
-          auth_config.GetString(kOAuthRefreshTokenConfigPath,
-                                &oauth_refresh_token_))) {
+    if (!config_.GetString(kXmppLoginConfigPath, &xmpp_login_) ||
+        !(config_.GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token_) ||
+          config_.GetString(kOAuthRefreshTokenConfigPath,
+                            &oauth_refresh_token_))) {
       LOG(ERROR) << "XMPP credentials are not defined in the config.";
       return false;
     }
 
     // It is okay to not have this value and we will use the default value
     // depending on whether this is an official build or not.
     // If the client-Id type to use is not specified we default based on
     // the build type.
-    auth_config.GetBoolean(kOAuthUseOfficialClientIdConfigPath,
-                           &oauth_use_official_client_id_);
+    config_.GetBoolean(kOAuthUseOfficialClientIdConfigPath,
+                       &oauth_use_official_client_id_);
 
     if (!oauth_refresh_token_.empty()) {
       xmpp_auth_token_ = "";  // This will be set to the access token later.
       xmpp_auth_service_ = "oauth2";
-    } else if (!auth_config.GetString(kXmppAuthServiceConfigPath,
-                                      &xmpp_auth_service_)) {
+    } else if (!config_.GetString(kXmppAuthServiceConfigPath,
+                                  &xmpp_auth_service_)) {
       // For the me2me host, we default to ClientLogin token for chromiumsync
       // because earlier versions of the host had no HTTP stack with which to
       // request an OAuth2 access token.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
     return true;
   }
 
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
     if (!context_->network_task_runner()->BelongsToCurrentThread()) {
@@ skipping 175 matching lines @@
     signaling_connector_.reset();
     signal_strategy_.reset();
 
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop message_loop_;
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
-  FilePath auth_config_path_;
-  FilePath host_config_path_;
+  CompositeHostConfig config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   std::string oauth_refresh_token_;
   bool oauth_use_official_client_id_;
@@ skipping 56 matching lines @@
   // Required for any calls into GTK functions, such as the Disconnect and
   // Continue windows, though these should not be used for the Me2Me case
   // (crbug.com/104377).
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_GTK
 
   // Enable support for SSL server sockets, which must be done while still
   // single-threaded.
   net::EnableSSLServerSockets();
 
+#if defined(OS_LINUX)
+    remoting::VideoFrameCapturer::EnableXDamage(true);
+#endif
+
   remoting::HostProcess me2me_host;
-  me2me_host.InitWithCommandLine(cmd_line);
+  if (!me2me_host.InitWithCommandLine(cmd_line)) {
+    return remoting::kInvalidHostConfigurationExitCode;
+  }
 
   return me2me_host.Run();
 }
 
 #if defined(OS_WIN)
 HMODULE g_hModule = NULL;
 
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
@@ skipping 25 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)