Revert of Renaming Gnubby and RemoteSecurityKey files/classes/members

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 54 matching lines @@
 #include "remoting/host/host_status_logger.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/ipc_desktop_environment.h"
 #include "remoting/host/ipc_host_event_logger.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/me2me_desktop_environment.h"
 #include "remoting/host/oauth_token_getter_impl.h"
 #include "remoting/host/pairing_registry_delegate.h"
 #include "remoting/host/pin_hash.h"
 #include "remoting/host/policy_watcher.h"
-#include "remoting/host/security_key/security_key_auth_handler.h"
-#include "remoting/host/security_key/security_key_extension.h"
+#include "remoting/host/security_key/gnubby_auth_handler.h"
+#include "remoting/host/security_key/gnubby_extension.h"
 #include "remoting/host/service_urls.h"
 #include "remoting/host/shutdown_watchdog.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/single_window_desktop_environment.h"
 #include "remoting/host/switches.h"
 #include "remoting/host/third_party_auth_config.h"
 #include "remoting/host/token_validator_factory_impl.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/username.h"
 #include "remoting/protocol/authenticator.h"
@@ skipping 57 matching lines @@
 // from stdin.
 const char kStdinConfigPath[] = "-";
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
 #if defined(OS_LINUX)
 // The command line switch used to pass name of the pipe to capture audio on
 // linux.
 const char kAudioPipeSwitchName[] = "audio-pipe-name";
 
 // The command line switch used to pass name of the unix domain socket used to
-// listen for security key requests.
+// listen for gnubby requests.
 const char kAuthSocknameSwitchName[] = "ssh-auth-sockname";
 #endif  // defined(OS_LINUX)
 
 // The command line switch used by the parent to request the host to signal it
 // when it is successfully started.
 const char kSignalParentSwitchName[] = "signal-parent";
 
 // Command line switch used to enable VP9 encoding.
 const char kEnableVp9SwitchName[] = "enable-vp9";
 
@@ skipping 202 matching lines @@
   std::string host_domain_;
   bool host_username_match_required_ = false;
   bool allow_nat_traversal_ = true;
   bool allow_relay_ = true;
   PortRange udp_port_range_;
   std::string talkgadget_prefix_;
   bool allow_pairing_ = true;
 
   bool curtain_required_ = false;
   ThirdPartyAuthConfig third_party_auth_config_;
-  bool security_key_auth_policy_enabled_ = false;
-  bool security_key_extension_supported_ = false;
+  bool gnubby_auth_policy_enabled_ = false;
+  bool gnubby_extension_supported_ = false;
 
   // Boolean to change flow, where necessary, if we're
   // capturing a window instead of the entire desktop.
   bool enable_window_capture_ = false;
 
   // Used to specify which window to stream, if enabled.
   webrtc::WindowId window_id_ = 0;
 
   // Must outlive |gcd_state_updater_| and |signaling_connector_|.
   std::unique_ptr<OAuthTokenGetter> oauth_token_getter_;
@@ skipping 420 matching lines @@
 #if defined(OS_LINUX)
   // If an audio pipe is specific on the command-line then initialize
   // AudioCapturerLinux to capture from it.
   base::FilePath audio_pipe_name = base::CommandLine::ForCurrentProcess()->
       GetSwitchValuePath(kAudioPipeSwitchName);
   if (!audio_pipe_name.empty()) {
     remoting::AudioCapturerLinux::InitializePipeReader(
         context_->audio_task_runner(), audio_pipe_name);
   }
 
-  base::FilePath security_key_socket_name =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-          kAuthSocknameSwitchName);
-  if (!security_key_socket_name.empty()) {
-    remoting::SecurityKeyAuthHandler::SetSecurityKeySocketName(
-        security_key_socket_name);
-    security_key_extension_supported_ = true;
+  base::FilePath gnubby_socket_name = base::CommandLine::ForCurrentProcess()->
+      GetSwitchValuePath(kAuthSocknameSwitchName);
+  if (!gnubby_socket_name.empty()) {
+    remoting::GnubbyAuthHandler::SetGnubbySocketName(gnubby_socket_name);
+    gnubby_extension_supported_ = true;
   }
 #elif defined(OS_WIN)
   // TODO(joedow): Remove the conditional once this is supported on OSX.
-  security_key_extension_supported_ = true;
+  gnubby_extension_supported_ = true;
 #endif  // defined(OS_WIN)
 
   // Create a desktop environment factory appropriate to the build type &
   // platform.
 #if defined(REMOTING_MULTI_PROCESS)
   IpcDesktopEnvironmentFactory* desktop_environment_factory =
       new IpcDesktopEnvironmentFactory(
           context_->audio_task_runner(), context_->network_task_runner(),
           context_->network_task_runner(), daemon_channel_.get());
   desktop_session_connector_ = desktop_environment_factory;
@@ skipping 472 matching lines @@
   } else {
     HOST_LOG << "Policy disables client pairing.";
   }
   return true;
 }
 
 bool HostProcess::OnGnubbyAuthPolicyUpdate(base::DictionaryValue* policies) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (!policies->GetBoolean(policy::key::kRemoteAccessHostAllowGnubbyAuth,
-                            &security_key_auth_policy_enabled_)) {
+                            &gnubby_auth_policy_enabled_)) {
     return false;
   }
 
-  if (security_key_auth_policy_enabled_) {
-    HOST_LOG << "Policy enables security key auth.";
+  if (gnubby_auth_policy_enabled_) {
+    HOST_LOG << "Policy enables gnubby auth.";
   } else {
-    HOST_LOG << "Policy disables security key auth.";
+    HOST_LOG << "Policy disables gnubby auth.";
   }
 
   return true;
 }
 
 void HostProcess::InitializeSignaling() {
   DCHECK(!host_id_.empty());  // ApplyConfig() should already have been run.
 
   DCHECK(!signal_strategy_);
   DCHECK(!oauth_token_getter_);
@@ skipping 113 matching lines @@
   if (enable_vp9_)
     protocol_config->set_vp9_experiment_enabled(true);
   protocol_config->set_webrtc_supported(true);
   session_manager->set_protocol_config(std::move(protocol_config));
 
   host_.reset(new ChromotingHost(desktop_environment_factory_.get(),
                                  std::move(session_manager), transport_context,
                                  context_->audio_task_runner(),
                                  context_->video_encode_task_runner()));
 
-  if (security_key_auth_policy_enabled_ && security_key_extension_supported_) {
-    host_->AddExtension(base::WrapUnique(new SecurityKeyExtension()));
+  if (gnubby_auth_policy_enabled_ && gnubby_extension_supported_) {
+    host_->AddExtension(base::WrapUnique(new GnubbyExtension()));
   }
 
   // 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_, signal_strategy_.get(), directory_bot_jid_));
 
@@ skipping 190 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(std::move(context), &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