[Chromoting] Add ProcessStatsDispatcher to send process stats to the client

remoting/host/security_key/security_key_extension_session.cc

 // 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.
 
 #include "remoting/host/security_key/security_key_extension_session.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
+#include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/client_session_details.h"
 #include "remoting/host/security_key/security_key_auth_handler.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/protocol/client_stub.h"
 
 namespace {
 
-// Used as the type attribute of all Security Key protocol::ExtensionMessages.
-const char kExtensionMessageType[] = "gnubby-auth";
-
 // SecurityKey extension message data members.
 const char kConnectionId[] = "connectionId";
 const char kControlMessage[] = "control";
 const char kControlOption[] = "option";
 const char kDataMessage[] = "data";
 const char kDataPayload[] = "data";
 const char kErrorMessage[] = "error";
 const char kSecurityKeyAuthV1[] = "auth-v1";
 const char kMessageType[] = "type";
 
@@ skipping 45 matching lines @@
 // Returns true if the |message| is a Security Key ExtensionMessage.
 // This is done so the host does not pass |message| to other HostExtensions.
 // TODO(joedow): Use |client_session_details| to disconnect the session if we
 //               receive an invalid extension message.
 bool SecurityKeyExtensionSession::OnExtensionMessage(
     ClientSessionDetails* client_session_details,
     protocol::ClientStub* client_stub,
     const protocol::ExtensionMessage& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (message.type() != kExtensionMessageType) {
+  if (message.type() != kSecurityKeyExtensionMessageType) {
     return false;
   }
 
   std::unique_ptr<base::Value> value = base::JSONReader::Read(message.data());
   base::DictionaryValue* client_message;
   if (!value || !value->GetAsDictionary(&client_message)) {
     LOG(WARNING) << "Failed to retrieve data from gnubby-auth message.";
     return true;
   }
 
@@ skipping 87 matching lines @@
   std::unique_ptr<base::ListValue> bytes(new base::ListValue());
   for (std::string::const_iterator i = data.begin(); i != data.end(); ++i) {
     bytes->AppendInteger(static_cast<unsigned char>(*i));
   }
   request.Set(kDataPayload, bytes.release());
 
   std::string request_json;
   CHECK(base::JSONWriter::Write(request, &request_json));
 
   protocol::ExtensionMessage message;
-  message.set_type(kExtensionMessageType);
+  message.set_type(kSecurityKeyExtensionMessageType);
   message.set_data(request_json);
 
   client_stub_->DeliverHostMessage(message);
 }
 
 void SecurityKeyExtensionSession::SetSecurityKeyAuthHandlerForTesting(
     std::unique_ptr<SecurityKeyAuthHandler> security_key_auth_handler) {
   DCHECK(security_key_auth_handler);
 
   security_key_auth_handler_ = std::move(security_key_auth_handler);
   security_key_auth_handler_->SetSendMessageCallback(
       base::Bind(&SecurityKeyExtensionSession::SendMessageToClient,
                  base::Unretained(this)));
 }
 
 }  // namespace remoting