TelemetryLogWriter cleanups

remoting/base/chromoting_event.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/signaling/chromoting_event.h"
+#include "remoting/base/chromoting_event.h"
 
 #include "base/sys_info.h"
 
 namespace remoting {
 
 const char ChromotingEvent::kCaptureLatencyKey[] = "capture_latency";
 const char ChromotingEvent::kConnectionErrorKey[] = "connection_error";
 const char ChromotingEvent::kCpuKey[] = "cpu";
 const char ChromotingEvent::kDecodeLatencyKey[] = "decode_latency";
 const char ChromotingEvent::kEncodeLatencyKey[] = "encode_latency";
@@ skipping 14 matching lines @@
 const char ChromotingEvent::kTypeKey[] = "type";
 const char ChromotingEvent::kVideoBandwidthKey[] = "video_bandwidth";
 
 ChromotingEvent::ChromotingEvent() : values_map_(new base::DictionaryValue()) {}
 
 ChromotingEvent::ChromotingEvent(Type type) : ChromotingEvent() {
   SetEnum(kTypeKey, type);
 }
 
 ChromotingEvent::ChromotingEvent(const ChromotingEvent& other) {
-  try_count_ = other.try_count_;
+  send_attempts_ = other.send_attempts_;
   values_map_ = other.values_map_->CreateDeepCopy();
 }
 
 ChromotingEvent::ChromotingEvent(ChromotingEvent&& other) {
-  try_count_ = other.try_count_;
+  send_attempts_ = other.send_attempts_;
   values_map_ = std::move(other.values_map_);
 }
 
 ChromotingEvent::~ChromotingEvent() {}
 
 ChromotingEvent& ChromotingEvent::operator=(const ChromotingEvent& other) {
   if (this != &other) {
-    try_count_ = other.try_count_;
+    send_attempts_ = other.send_attempts_;
     values_map_ = other.values_map_->CreateDeepCopy();
   }
   return *this;
 }
 
 ChromotingEvent& ChromotingEvent::operator=(ChromotingEvent&& other) {
-  try_count_ = other.try_count_;
+  send_attempts_ = other.send_attempts_;
   values_map_ = std::move(other.values_map_);
   return *this;
 }
 
 void ChromotingEvent::SetString(const std::string& key,
                                 const std::string& value) {
   values_map_->SetString(key, value);
 }
 
 void ChromotingEvent::SetInteger(const std::string& key, int value) {
@@ skipping 23 matching lines @@
 #elif defined(OS_ANDROID)
   Os os = Os::CHROMOTING_ANDROID;
 #elif defined(OS_IOS)
   Os os = Os::CHROMOTING_IOS;
 #else
   Os os = Os::OTHER;
 #endif
   SetEnum(kOsKey, os);
 }
 
-void ChromotingEvent::IncrementTryCount() {
-  try_count_++;
+void ChromotingEvent::IncrementSendAttempts() {
+  send_attempts_++;
 }
 
 std::unique_ptr<base::DictionaryValue> ChromotingEvent::CopyDictionaryValue()
     const {
   return values_map_->CreateDeepCopy();
 }
 
 // static
 bool ChromotingEvent::IsEndOfSession(SessionState state) {
   return state == SessionState::CLOSED ||
          state == SessionState::CONNECTION_DROPPED ||
          state == SessionState::CONNECTION_FAILED ||
          state == SessionState::CONNECTION_CANCELED;
 }
 
 }  // namespace remoting