FileWrapper[Impl] modifications and actually remove the "Impl" class.

webrtc/system_wrappers/source/trace_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 54 matching lines @@
 }
 
 TraceImpl::TraceImpl()
     : callback_(NULL),
       row_count_text_(0),
       file_count_text_(0),
       trace_file_(FileWrapper::Create()) {
 }
 
 TraceImpl::~TraceImpl() {
-  trace_file_->Flush();
   trace_file_->CloseFile();
 }
 
 int32_t TraceImpl::AddThreadId(char* trace_message) const {
   uint32_t thread_id = rtc::CurrentThreadId();
   // Messages is 12 characters.
   return sprintf(trace_message, "%10u; ", thread_id);
 }
 
 int32_t TraceImpl::AddLevel(char* sz_message, const TraceLevel level) const {
@@ skipping 194 matching lines @@
         break;
     }
   }
   return kMessageLength;
 }
 
 int32_t TraceImpl::SetTraceFileImpl(const char* file_name_utf8,
                                     const bool add_file_counter) {
   rtc::CritScope lock(&crit_);
 
-  trace_file_->Flush();
   trace_file_->CloseFile();
+  trace_file_path_.clear();
 
   if (file_name_utf8) {
     if (add_file_counter) {
       file_count_text_ = 1;
 
       char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize];
       CreateFileName(file_name_utf8, file_name_with_counter_utf8,
                      file_count_text_);
-      if (trace_file_->OpenFile(file_name_with_counter_utf8, false, false,
-                               true) == -1) {
+      if (trace_file_->OpenFile(file_name_with_counter_utf8, false) == -1) {
         return -1;
       }
+      trace_file_path_ = file_name_with_counter_utf8;
     } else {
       file_count_text_ = 0;
-      if (trace_file_->OpenFile(file_name_utf8, false, false, true) == -1) {
+      if (trace_file_->OpenFile(file_name_utf8, false) == -1) {
         return -1;
       }
+      trace_file_path_ = file_name_utf8;
     }
   }
   row_count_text_ = 0;
   return 0;
 }
 
-int32_t TraceImpl::TraceFileImpl(
-    char file_name_utf8[FileWrapper::kMaxFileNameSize]) {
-  rtc::CritScope lock(&crit_);
-  return trace_file_->FileName(file_name_utf8, FileWrapper::kMaxFileNameSize);
-}
-
 int32_t TraceImpl::SetTraceCallbackImpl(TraceCallback* callback) {
   rtc::CritScope lock(&crit_);
   callback_ = callback;
   return 0;
 }
 
 int32_t TraceImpl::AddMessage(
     char* trace_message,
     const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
     const uint16_t written_so_far) const {
@@ skipping 28 matching lines @@
     const char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
     const uint16_t length,
     const TraceLevel level) {
   rtc::CritScope lock(&crit_);
   if (callback_)
     callback_->Print(level, trace_message, length);
   WriteToFile(trace_message, length);
 }
 
 void TraceImpl::WriteToFile(const char* msg, uint16_t length) {
-  if (!trace_file_->Open())
+  if (!trace_file_->is_open())
     return;
 
   if (row_count_text_ > WEBRTC_TRACE_MAX_FILE_SIZE) {
     // wrap file
     row_count_text_ = 0;
     trace_file_->Flush();
 
     if (file_count_text_ == 0) {
       trace_file_->Rewind();
     } else {
-      char old_file_name[FileWrapper::kMaxFileNameSize];
       char new_file_name[FileWrapper::kMaxFileNameSize];
 
       // get current name
-      trace_file_->FileName(old_file_name, FileWrapper::kMaxFileNameSize);
+      file_count_text_++;
+      UpdateFileName(new_file_name, file_count_text_);
+
       trace_file_->CloseFile();
+      trace_file_path_.clear();
 
-      file_count_text_++;
-
-      UpdateFileName(old_file_name, new_file_name, file_count_text_);
-
-      if (trace_file_->OpenFile(new_file_name, false, false, true) == -1) {
+      if (trace_file_->OpenFile(new_file_name, false) == -1) {
         return;
       }
+      trace_file_path_ = new_file_name;
     }
   }
   if (row_count_text_ == 0) {
     char message[WEBRTC_TRACE_MAX_MESSAGE_SIZE + 1];
     int32_t length = AddDateTimeInfo(message);
     if (length != -1) {
       message[length] = 0;
       message[length - 1] = '\n';
       trace_file_->Write(message, length);
       row_count_text_++;
@@ skipping 51 matching lines @@
 
   ack_len += len;
   AddMessageToList(trace_message, static_cast<uint16_t>(ack_len), level);
 }
 
 bool TraceImpl::TraceCheck(const TraceLevel level) const {
   return (level & level_filter()) ? true : false;
 }
 
 bool TraceImpl::UpdateFileName(
-    const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
     const uint32_t new_count) const {
-  int32_t length = (int32_t)strlen(file_name_utf8);
-  if (length < 0) {
-    return false;
-  }
+  int32_t length = static_cast<int32_t>(trace_file_path_.length());
 
   int32_t length_without_file_ending = length - 1;
   while (length_without_file_ending > 0) {
-    if (file_name_utf8[length_without_file_ending] == '.') {
+    if (trace_file_path_[length_without_file_ending] == '.') {
       break;
     } else {
       length_without_file_ending--;
     }
   }
   if (length_without_file_ending == 0) {
     length_without_file_ending = length;
   }
   int32_t length_to_ = length_without_file_ending - 1;
   while (length_to_ > 0) {
-    if (file_name_utf8[length_to_] == '_') {
+    if (trace_file_path_[length_to_] == '_') {
       break;
     } else {
       length_to_--;
     }
   }
 
-  memcpy(file_name_with_counter_utf8, file_name_utf8, length_to_);
+  memcpy(file_name_with_counter_utf8, &trace_file_path_[0], length_to_);
   sprintf(file_name_with_counter_utf8 + length_to_, "_%lu%s",
           static_cast<long unsigned int>(new_count),
-          file_name_utf8 + length_without_file_ending);
+          &trace_file_path_[length_without_file_ending]);
   return true;
 }
 
 bool TraceImpl::CreateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
     const uint32_t new_count) const {
   int32_t length = (int32_t)strlen(file_name_utf8);
   if (length < 0) {
     return false;
@@ skipping 22 matching lines @@
 void Trace::CreateTrace() {
   TraceImpl::StaticInstance(kAddRef);
 }
 
 // static
 void Trace::ReturnTrace() {
   TraceImpl::StaticInstance(kRelease);
 }
 
 // static
-int32_t Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) {
-  TraceImpl* trace = TraceImpl::GetTrace();
-  if (trace) {
-    int ret_val = trace->TraceFileImpl(file_name);
-    ReturnTrace();
-    return ret_val;
-  }
-  return -1;
-}
-
-// static
 void Trace::set_level_filter(int filter) {
   rtc::AtomicOps::ReleaseStore(&level_filter_, filter);
 }
 
 // static
 int Trace::level_filter() {
   return rtc::AtomicOps::AcquireLoad(&level_filter_);
 }
 
 // static
@@ skipping 36 matching lines @@
         va_end(args);
         buff = temp_buff;
       }
       trace->AddImpl(level, module, id, buff);
     }
     ReturnTrace();
   }
 }
 
 }  // namespace webrtc