Clean up PlatformThread.

webrtc/system_wrappers/source/data_log.cc

 /*
  *  Copyright (c) 2011 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 300 matching lines @@
 }
 
 int DataLog::NextRow(const std::string& table_name) {
   DataLogImpl* data_log = DataLogImpl::StaticInstance();
   if (data_log == NULL)
     return -1;
   return data_log->DataLogImpl::StaticInstance()->NextRow(table_name);
 }
 
 DataLogImpl::DataLogImpl()
-  : counter_(1),
-    tables_(),
-    flush_event_(EventWrapper::Create()),
-    tables_lock_(RWLockWrapper::CreateRWLock()) {
-}
+    : counter_(1),
+      tables_(),
+      flush_event_(EventWrapper::Create()),
+      file_writer_thread_(
+          new rtc::PlatformThread(DataLogImpl::Run, instance_, "DataLog")),
+      tables_lock_(RWLockWrapper::CreateRWLock()) {}
 
 DataLogImpl::~DataLogImpl() {
   StopThread();
   Flush();  // Write any remaining rows
   delete flush_event_;
   for (TableMap::iterator it = tables_.begin(); it != tables_.end();) {
     delete static_cast<LogTable*>(it->second);
     // For maps all iterators (except the erased) are valid after an erase
     tables_.erase(it++);
   }
   delete tables_lock_;
 }
 
 int DataLogImpl::CreateLog() {
   CriticalSectionScoped synchronize(crit_sect_.get());
   if (instance_ == NULL) {
     instance_ = new DataLogImpl();
     return instance_->Init();
   } else {
     ++instance_->counter_;
   }
   return 0;
 }
 
 int DataLogImpl::Init() {
-  file_writer_thread_ =
-      PlatformThread::CreateThread(DataLogImpl::Run, instance_, "DataLog");
-  bool success = file_writer_thread_->Start();
-  if (!success)
-    return -1;
-  file_writer_thread_->SetPriority(kHighestPriority);
+  file_writer_thread_->Start();
+  file_writer_thread_->SetPriority(rtc::kHighestPriority);
   return 0;
 }
 
 DataLogImpl* DataLogImpl::StaticInstance() {
   return instance_;
 }
 
 void DataLogImpl::ReturnLog() {
   CriticalSectionScoped synchronize(crit_sect_.get());
   if (instance_ && instance_->counter_ > 1) {
@@ skipping 32 matching lines @@
   if (tables_.count(table_name) == 0)
     return -1;
   return tables_[table_name]->InsertCell(column_name, value_container);
 }
 
 int DataLogImpl::NextRow(const std::string& table_name) {
   ReadLockScoped synchronize(*tables_lock_);
   if (tables_.count(table_name) == 0)
     return -1;
   tables_[table_name]->NextRow();
-  if (!file_writer_thread_) {
-    // Write every row to file as they get complete.
-    tables_[table_name]->Flush();
-  } else {
-    // Signal a complete row
-    flush_event_->Set();
-  }
+  // Signal a complete row
+  flush_event_->Set();
   return 0;
 }
 
 void DataLogImpl::Flush() {
   ReadLockScoped synchronize(*tables_lock_);
   for (TableMap::iterator it = tables_.begin(); it != tables_.end(); ++it) {
     it->second->Flush();
   }
 }
 
 bool DataLogImpl::Run(void* obj) {
   static_cast<DataLogImpl*>(obj)->Process();
   return true;
 }
 
 void DataLogImpl::Process() {
   // Wait for a row to be complete
   flush_event_->Wait(WEBRTC_EVENT_INFINITE);
   Flush();
 }
 
 void DataLogImpl::StopThread() {
-  if (file_writer_thread_) {
-    flush_event_->Set();
-    file_writer_thread_->Stop();
-  }
+  flush_event_->Set();
+  file_writer_thread_->Stop();
 }
 
 }  // namespace webrtc