Fix device_event_log component build, make NonThreadSafe (Take 2)

components/device_event_log/device_event_log_impl.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 "components/device_event_log/device_event_log_impl.h"
 
 #include <cmath>
 #include <list>
 #include <set>
 
+#include "base/bind.h"
 #include "base/containers/adapters.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/escape.h"
 
 namespace device_event_log {
@@ skipping 216 matching lines @@
       if (type != LOG_TYPE_UNKNOWN)
         exclude_types->insert(type);
     } else {
       LogType type = LogTypeFromString(tok);
       if (type != LOG_TYPE_UNKNOWN)
         include_types->insert(type);
     }
   }
 }
 
+// Update count and time for identical events to avoid log spam.
+void IncreaseLogEntryCount(const DeviceEventLogImpl::LogEntry& new_entry,
+                           DeviceEventLogImpl::LogEntry* cur_entry) {
+  ++cur_entry->count;
+  cur_entry->log_level = std::min(cur_entry->log_level, new_entry.log_level);
+  cur_entry->time = base::Time::Now();
+}
+
 }  // namespace
 
 // static
 void DeviceEventLogImpl::SendToVLogOrErrorLog(const char* file,
                                               int file_line,
                                               LogType log_type,
                                               LogLevel log_level,
                                               const std::string& event) {
   LogEntry entry(file, file_line, log_type, log_level, event);
   SendLogEntryToVLogOrErrorLog(entry);
 }
 
-DeviceEventLogImpl::DeviceEventLogImpl(size_t max_entries)
-    : max_entries_(max_entries) {
+DeviceEventLogImpl::DeviceEventLogImpl(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    size_t max_entries)
+    : task_runner_(task_runner),
+      max_entries_(max_entries),
+      weak_ptr_factory_(this) {
+  DCHECK(task_runner_);
 }
 
 DeviceEventLogImpl::~DeviceEventLogImpl() {
 }
 
 void DeviceEventLogImpl::AddEntry(const char* file,
                                   int file_line,
                                   LogType log_type,
                                   LogLevel log_level,
                                   const std::string& event) {
   LogEntry entry(file, file_line, log_type, log_level, event);
+  if (!task_runner_->RunsTasksOnCurrentThread()) {
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&DeviceEventLogImpl::AddLogEntry,
+                                      weak_ptr_factory_.GetWeakPtr(), entry));
+    return;
+  }
   AddLogEntry(entry);
 }
 
 void DeviceEventLogImpl::AddLogEntry(const LogEntry& entry) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   if (!entries_.empty()) {
     LogEntry& last = entries_.back();
     if (LogEntryMatches(last, entry)) {
-      // Update count and time for identical events to avoid log spam.
-      ++last.count;
-      last.log_level = std::min(last.log_level, entry.log_level);
-      last.time = base::Time::Now();
+      IncreaseLogEntryCount(entry, &last);
       return;
     }
   }
-  if (entries_.size() >= max_entries_) {
-    const size_t max_error_entries = max_entries_ / 2;
-    // Remove the first (oldest) non-error entry, or the oldest entry if more
-    // than half the entries are errors.
-    size_t error_count = 0;
-    for (LogEntryList::iterator iter = entries_.begin(); iter != entries_.end();
-         ++iter) {
-      if (iter->log_level != LOG_LEVEL_ERROR) {
-        entries_.erase(iter);
-        break;
-      }
-      if (++error_count > max_error_entries) {
-        // Too many error entries, remove the oldest entry.
-        entries_.pop_front();
-        break;
-      }
-    }
-  }
+  if (entries_.size() >= max_entries_)
+    RemoveEntry();
   entries_.push_back(entry);
   SendLogEntryToVLogOrErrorLog(entry);
 }
 
+void DeviceEventLogImpl::RemoveEntry() {
+  const size_t max_error_entries = max_entries_ / 2;
+  DCHECK(max_error_entries < entries_.size());
+  // Remove the first (oldest) non-error entry, or the oldest entry if more
+  // than half the entries are errors.
+  size_t error_count = 0;
+  for (LogEntryList::iterator iter = entries_.begin(); iter != entries_.end();
+       ++iter) {
+    if (iter->log_level != LOG_LEVEL_ERROR) {
+      entries_.erase(iter);
+      return;
+    }
+    if (++error_count > max_error_entries)
+      break;
+  }
+  // Too many error entries, remove the oldest entry.
+  entries_.pop_front();
+}
+
 std::string DeviceEventLogImpl::GetAsString(StringOrder order,
                                             const std::string& format,
                                             const std::string& types,
                                             LogLevel max_level,
                                             size_t max_events) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   if (entries_.empty())
     return "No Log Entries.";
 
   bool show_time, show_file, show_type, show_level, format_html, format_json;
   GetFormat(format, &show_time, &show_file, &show_type, &show_level,
             &format_html, &format_json);
 
   std::set<LogType> include_types, exclude_types;
   GetLogTypes(types, &include_types, &exclude_types);
 
@@ skipping 75 matching lines @@
   if (filedesc) {
     file = filedesc;
     size_t last_slash_pos = file.find_last_of("\\/");
     if (last_slash_pos != std::string::npos) {
       file.erase(0, last_slash_pos + 1);
     }
   }
 }
 
 }  // namespace device_event_log