Pull out common code from client and host versions of ServerLogEntry.

remoting/client/server_log_entry_client.cc

 // Copyright 2014 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/client/server_log_entry.h"
+#include "remoting/client/server_log_entry_client.h"
 
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
-#include "remoting/base/constants.h"
 #include "remoting/client/chromoting_stats.h"
-#include "remoting/protocol/connection_to_host.h"
-#include "remoting/protocol/errors.h"
-#include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
+#include "remoting/jingle_glue/server_log_entry.h"
 
 using base::StringPrintf;
 using base::SysInfo;
-using buzz::QName;
-using buzz::XmlElement;
 using remoting::protocol::ConnectionToHost;
+using remoting::protocol::ErrorCode;
 
 namespace remoting {
 
-namespace client {
+namespace {
+const char kValueRoleClient[] = "client";
 
-namespace {
-const char kLogCommand[] = "log";
-
-const char kLogEntry[] = "entry";
-
-const char kKeyEventName[] = "event-name";
 const char kValueEventNameSessionState[] = "session-state";
 const char kValueEventNameStatistics[] = "connection-statistics";
 const char kValueEventNameSessionIdOld[] = "session-id-old";
 const char kValueEventNameSessionIdNew[] = "session-id-new";
 
-const char kKeyRole[] = "role";
-const char kValueRoleClient[] = "client";
-
-const char kKeyMode[] = "mode";
-const char kValueModeIt2Me[] = "it2me";
-const char kValueModeMe2Me[] = "me2me";
+const char kKeySessionId[] = "session-id";
+const char kKeySessionDuration[] = "session-duration";
 
 const char kKeySessionState[] = "session-state";
+const char kKeyConnectionError[] = "connection-error";
 const char kValueSessionStateConnected[] = "connected";
 const char kValueSessionStateClosed[] = "closed";
 
 const char kKeyOsName[] = "os-name";
 const char kKeyOsVersion[] = "os-version";
 const char kKeyAppVersion[] = "app-version";
 
-const char kKeyCpu[] = "cpu";
-
-}  // namespace
-
-ServerLogEntry::ServerLogEntry() {
-}
-
-ServerLogEntry::~ServerLogEntry() {
-}
-
-// static
-scoped_ptr<buzz::XmlElement> ServerLogEntry::MakeStanza() {
-  return scoped_ptr<buzz::XmlElement>(
-      new XmlElement(QName(kChromotingXmlNamespace, kLogCommand)));
-}
-
-// static
-scoped_ptr<ServerLogEntry> ServerLogEntry::MakeForSessionStateChange(
-    protocol::ConnectionToHost::State state,
-    protocol::ErrorCode error) {
-  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
-  entry->Set(kKeyRole, kValueRoleClient);
-  entry->Set(kKeyEventName, kValueEventNameSessionState);
-
-  entry->Set(kKeySessionState, GetValueSessionState(state));
-  if (error != protocol::OK) {
-    entry->Set("connection-error", GetValueError(error));
-  }
-
-  return entry.Pass();
-}
-
-// static
-scoped_ptr<ServerLogEntry> ServerLogEntry::MakeForStatistics(
-    ChromotingStats* statistics) {
-  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
-  entry->Set(kKeyRole, kValueRoleClient);
-  entry->Set(kKeyEventName, kValueEventNameStatistics);
-
-  entry->Set("video-bandwidth",
-             StringPrintf("%.2f", statistics->video_bandwidth()->Rate()));
-  entry->Set("capture-latency",
-             StringPrintf("%.2f", statistics->video_capture_ms()->Average()));
-  entry->Set("encode-latency",
-             StringPrintf("%.2f", statistics->video_encode_ms()->Average()));
-  entry->Set("decode-latency",
-             StringPrintf("%.2f", statistics->video_decode_ms()->Average()));
-  entry->Set("render-latency",
-             StringPrintf("%.2f", statistics->video_frame_rate()->Rate()));
-  entry->Set("roundtrip-latency",
-             StringPrintf("%.2f", statistics->round_trip_ms()->Average()));
-
-  return entry.Pass();
-}
-
-// static
-scoped_ptr<ServerLogEntry> ServerLogEntry::MakeForSessionIdOld(
-    const std::string& session_id) {
-  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
-  entry->Set(kKeyRole, kValueRoleClient);
-  entry->Set(kKeyEventName, kValueEventNameSessionIdOld);
-  entry->AddSessionId(session_id);
-  return entry.Pass();
-}
-
-// static
-scoped_ptr<ServerLogEntry> ServerLogEntry::MakeForSessionIdNew(
-    const std::string& session_id) {
-  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
-  entry->Set(kKeyRole, kValueRoleClient);
-  entry->Set(kKeyEventName, kValueEventNameSessionIdNew);
-  entry->AddSessionId(session_id);
-  return entry.Pass();
-}
-
-void ServerLogEntry::AddClientFields() {
-  Set(kKeyOsName, SysInfo::OperatingSystemName());
-  Set(kKeyOsVersion, SysInfo::OperatingSystemVersion());
-  Set(kKeyAppVersion, STRINGIZE(VERSION));
-  Set(kKeyCpu, SysInfo::OperatingSystemArchitecture());
-};
-
-void ServerLogEntry::AddModeField(ServerLogEntry::Mode mode) {
-  Set(kKeyMode, GetValueMode(mode));
-}
-
-void ServerLogEntry::AddSessionId(const std::string& session_id) {
-  Set("session-id", session_id);
-}
-
-void ServerLogEntry::AddSessionDuration(base::TimeDelta duration) {
-  Set("session-duration", base::Int64ToString(duration.InSeconds()));
-}
-
-// static
-const char* ServerLogEntry::GetValueMode(ServerLogEntry::Mode mode) {
-  switch (mode) {
-    case IT2ME:
-      return kValueModeIt2Me;
-    case ME2ME:
-      return kValueModeMe2Me;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-scoped_ptr<XmlElement> ServerLogEntry::ToStanza() const {
-  scoped_ptr<XmlElement> stanza(new XmlElement(QName(
-      kChromotingXmlNamespace, kLogEntry)));
-  ValuesMap::const_iterator iter;
-  for (iter = values_map_.begin(); iter != values_map_.end(); ++iter) {
-    stanza->AddAttr(QName(std::string(), iter->first), iter->second);
-  }
-  return stanza.Pass();
-}
-
-// static
-const char* ServerLogEntry::GetValueSessionState(
-    ConnectionToHost::State state) {
+const char* GetValueSessionState(ConnectionToHost::State state) {
   switch (state) {
     // Where possible, these are the same strings that the webapp sends for the
     // corresponding state - see remoting/webapp/server_log_entry.js.
     case ConnectionToHost::INITIALIZING:
       return "initializing";
     case ConnectionToHost::CONNECTING:
       return "connecting";
     case ConnectionToHost::AUTHENTICATED:
       return "authenticated";
     case ConnectionToHost::CONNECTED:
       return kValueSessionStateConnected;
     case ConnectionToHost::FAILED:
       return "connection-failed";
     case ConnectionToHost::CLOSED:
       return kValueSessionStateClosed;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
-// static
-const char* ServerLogEntry::GetValueError(protocol::ErrorCode error) {
+const char* GetValueError(ErrorCode error) {
   switch (error) {
     // Where possible, these are the same strings that the webapp sends for the
     // corresponding error - see remoting/webapp/server_log_entry.js.
     case protocol::OK:
       return "none";
     case protocol::PEER_IS_OFFLINE:
       return "host-is-offline";
     case protocol::SESSION_REJECTED:
       return "session-rejected";
     case protocol::INCOMPATIBLE_PROTOCOL:
       return "incompatible-protocol";
     case protocol::AUTHENTICATION_FAILED:
       return "authentication-failed";
     case protocol::CHANNEL_CONNECTION_ERROR:
       return "channel-connection-error";
     case protocol::SIGNALING_ERROR:
       return "signaling-error";
     case protocol::SIGNALING_TIMEOUT:
       return "signaling-timeout";
     case protocol::HOST_OVERLOAD:
       return "host-overload";
     case protocol::UNKNOWN_ERROR:
       return "unknown-error";
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
-void ServerLogEntry::AddEventName(const std::string& event_name) {
-  Set("event-name", event_name);
+}  // namespace
+
+scoped_ptr<ServerLogEntry> MakeLogEntryForSessionStateChange(
+    ConnectionToHost::State state,
+    ErrorCode error) {
+  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
+  entry->AddRoleField(kValueRoleClient);
+  entry->AddEventNameField(kValueEventNameSessionState);
+
+  entry->Set(kKeySessionState, GetValueSessionState(state));
+  if (error != protocol::OK) {
+    entry->Set(kKeyConnectionError, GetValueError(error));
+  }
+
+  return entry.Pass();
 }
 
-void ServerLogEntry::Set(const std::string& key, const std::string& value) {
-  values_map_[key] = value;
+scoped_ptr<ServerLogEntry> MakeLogEntryForStatistics(
+    ChromotingStats* statistics) {
+  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
+  entry->AddRoleField(kValueRoleClient);
+  entry->AddEventNameField(kValueEventNameStatistics);
+
+  entry->Set("video-bandwidth",
+             StringPrintf("%.2f", statistics->video_bandwidth()->Rate()));
+  entry->Set("capture-latency",
+             StringPrintf("%.2f", statistics->video_capture_ms()->Average()));
+  entry->Set("encode-latency",
+             StringPrintf("%.2f", statistics->video_encode_ms()->Average()));
+  entry->Set("decode-latency",
+             StringPrintf("%.2f", statistics->video_decode_ms()->Average()));
+  entry->Set("render-latency",
+             StringPrintf("%.2f", statistics->video_frame_rate()->Rate()));
+  entry->Set("roundtrip-latency",
+             StringPrintf("%.2f", statistics->round_trip_ms()->Average()));
+
+  return entry.Pass();
 }
 
-}  // namespace client
+scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdOld(
+    const std::string& session_id) {
+  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
+  entry->AddRoleField(kValueRoleClient);
+  entry->AddEventNameField(kValueEventNameSessionIdOld);
+  AddSessionIdToLogEntry(entry.get(), session_id);
+  return entry.Pass();
+}
+
+scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdNew(
+    const std::string& session_id) {
+  scoped_ptr<ServerLogEntry> entry(new ServerLogEntry());
+  entry->AddRoleField(kValueRoleClient);
+  entry->AddEventNameField(kValueEventNameSessionIdNew);
+  AddSessionIdToLogEntry(entry.get(), session_id);
+  return entry.Pass();
+}
+
+void AddClientFieldsToLogEntry(ServerLogEntry* entry) {
+  entry->Set(kKeyOsName, SysInfo::OperatingSystemName());
+  entry->Set(kKeyOsVersion, SysInfo::OperatingSystemVersion());
+  entry->Set(kKeyAppVersion, STRINGIZE(VERSION));
+  entry->AddCpuField();
+}
+
+void AddSessionIdToLogEntry(ServerLogEntry* entry, const std::string& id) {
+  entry->Set(kKeySessionId, id);
+}
+
+void AddSessionDurationToLogEntry(ServerLogEntry* entry,
+                                  base::TimeDelta duration) {
+  entry->Set(kKeySessionDuration, base::Int64ToString(duration.InSeconds()));
+}
 
 }  // namespace remoting