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

remoting/client/log_to_server.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/log_to_server.h"
 
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "remoting/base/constants.h"
 #include "remoting/client/chromoting_stats.h"
+#include "remoting/client/server_log_entry_client.h"
 #include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 #include "third_party/libjingle/source/talk/xmpp/constants.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 using remoting::protocol::ConnectionToHost;
+using remoting::protocol::ServerLogEntry;
 
 namespace {
 
 const char kSessionIdAlphabet[] =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 const int kSessionIdLength = 20;
 
 const int kMaxSessionIdAgeDays = 1;
 
 bool IsStartOfSession(ConnectionToHost::State state) {
@@ skipping 33 matching lines @@
 LogToServer::~LogToServer() {
   signal_strategy_->RemoveListener(this);
 }
 
 void LogToServer::LogSessionStateChange(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
   scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForSessionStateChange(state, error));
-  entry->AddClientFields();
+      MakeLogEntryForSessionStateChange(state, error));
+  AddClientFieldsToLogEntry(entry.get());
   entry->AddModeField(mode_);
 
   MaybeExpireSessionId();
   if (IsStartOfSession(state)) {
     // Maybe set the session ID and start time.
     if (session_id_.empty()) {
       GenerateSessionId();
     }
     if (session_start_time_.is_null()) {
       session_start_time_ = base::TimeTicks::Now();
     }
   }
 
   if (!session_id_.empty()) {
-    entry->AddSessionId(session_id_);
+    AddSessionIdToLogEntry(entry.get(), session_id_);
   }
 
   // Maybe clear the session start time and log the session duration.
   if (ShouldAddDuration(state) && !session_start_time_.is_null()) {
-    entry->AddSessionDuration(base::TimeTicks::Now() - session_start_time_);
+    AddSessionDurationToLogEntry(entry.get(),
+                                 base::TimeTicks::Now() - session_start_time_);
   }
 
   if (IsEndOfSession(state)) {
     session_start_time_ = base::TimeTicks();
     session_id_.clear();
   }
 
   Log(*entry.get());
 }
 
 void LogToServer::LogStatistics(ChromotingStats* statistics) {
   DCHECK(CalledOnValidThread());
 
   MaybeExpireSessionId();
 
-  scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForStatistics(statistics));
-  entry->AddClientFields();
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForStatistics(statistics));
+  AddClientFieldsToLogEntry(entry.get());
   entry->AddModeField(mode_);
-  entry->AddSessionId(session_id_);
+  AddSessionIdToLogEntry(entry.get(), session_id_);
   Log(*entry.get());
 }
 
 void LogToServer::OnSignalStrategyStateChange(SignalStrategy::State state) {
   DCHECK(CalledOnValidThread());
 
   if (state == SignalStrategy::CONNECTED) {
     iq_sender_.reset(new IqSender(signal_strategy_));
     SendPendingEntries();
   } else if (state == SignalStrategy::DISCONNECTED) {
@@ skipping 43 matching lines @@
 }
 
 void LogToServer::MaybeExpireSessionId() {
   if (session_id_.empty()) {
     return;
   }
 
   base::TimeDelta max_age = base::TimeDelta::FromDays(kMaxSessionIdAgeDays);
   if (base::TimeTicks::Now() - session_id_generation_time_ > max_age) {
     // Log the old session ID.
-    scoped_ptr<ServerLogEntry> entry(
-        ServerLogEntry::MakeForSessionIdOld(session_id_));
+    scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionIdOld(session_id_));
     entry->AddModeField(mode_);
     Log(*entry.get());
 
     // Generate a new session ID.
     GenerateSessionId();
 
     // Log the new session ID.
-    entry = ServerLogEntry::MakeForSessionIdNew(session_id_);
+    entry = MakeLogEntryForSessionIdNew(session_id_);
     entry->AddModeField(mode_);
     Log(*entry.get());
   }
 }
 
 }  // namespace client
 
 }  // namespace remoting