Renaming Gnubby and RemoteSecurityKey files/classes/members

remoting/host/security_key/security_key_message.h

 // Copyright 2016 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_SECURITY_KEY_SECURITY_KEY_MESSAGE_H_
 #define REMOTING_HOST_SECURITY_KEY_SECURITY_KEY_MESSAGE_H_
 
 #include <cstdint>
 #include <memory>
 #include <string>
@@ skipping 26 matching lines @@
 //          Multi-byte payloads which are part of the security key request and
 //          response messages are expected to be big endian.  The bytes for
 //          these messages will be transmitted across the network as-is.
 //          The format for all other payloads is the endianness of the platform.
 
 // -----------------------------------------------------------------------------
 // Messages
 // -----------------------------------------------------------------------------
 // NOTE: Make sure SecurityKeyMessage::MessageTypeFromValue is updated when new
 //       enum values are added/removed.
-enum class RemoteSecurityKeyMessageType : uint8_t {
+enum class SecurityKeyMessageType : uint8_t {
   INVALID = 0,
 
   // Sent to the remote_security_key process to ask it to establish a
   // connection to the Chromoting host if a security key enabled session
   // exists for the current user.
   // Payload length: 0
   CONNECT = 1,
 
   // Sent is sent by the remote_security_key process in response to a
   // |kConnectToSecurityKeyEnabledSessionMsg| request.
@@ skipping 50 matching lines @@
   // The number of bytes used to represent the message type.
   static const int kMessageTypeSizeBytes;
 
   SecurityKeyMessage();
   ~SecurityKeyMessage();
 
   // When given a header value (uint32_t), this method will return whether the
   // length is within the allowable size range.
   static bool IsValidMessageSize(uint32_t message_size);
 
-  // Returns a RemoteSecurityKeyMessageType enum value corresponding to the
+  // Returns a SecurityKeyMessageType enum value corresponding to the
   // value passed in if it is valid, otherwise INVALID is returned.
-  static RemoteSecurityKeyMessageType MessageTypeFromValue(int value);
+  static SecurityKeyMessageType MessageTypeFromValue(int value);
 
   // Creates a message from the passed in values, no validation is done as this
   // method is only expected to be called from test code.
   static std::unique_ptr<SecurityKeyMessage> CreateMessageForTest(
-      RemoteSecurityKeyMessageType type,
+      SecurityKeyMessageType type,
       const std::string& payload);
 
   // Parses |message_data| and initializes the internal members.  Returns true
   // if |message_data| was parsed and the instance was initialized successfully.
   bool ParseMessage(const std::string& message_data);
 
-  RemoteSecurityKeyMessageType type() { return type_; }
+  SecurityKeyMessageType type() { return type_; }
 
   const std::string& payload() { return payload_; }
 
  private:
-  RemoteSecurityKeyMessageType type_ = RemoteSecurityKeyMessageType::INVALID;
+  SecurityKeyMessageType type_ = SecurityKeyMessageType::INVALID;
   std::string payload_;
 
   DISALLOW_COPY_AND_ASSIGN(SecurityKeyMessage);
 };
 
-// Used to pass remote security key message data between classes.
+// Used to pass security key message data between classes.
 typedef base::Callback<void(std::unique_ptr<SecurityKeyMessage> message)>
     SecurityKeyMessageCallback;
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SECURITY_KEY_SECURITY_KEY_MESSAGE_H_