Move OomKillsMonitor from a single-threaded SequencedWorkerPool to a non-joinable thread.

components/arc/metrics/oom_kills_monitor.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 "components/arc/metrics/oom_kills_monitor.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/posix/safe_strerror.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
 #include "components/arc/metrics/oom_kills_histogram.h"
 #include "third_party/re2/src/re2/re2.h"
 #include "third_party/re2/src/re2/stringpiece.h"
 
 namespace arc {
 
 using base::StringPiece;
 
 using base::SequencedWorkerPool;
 using base::TimeDelta;
 
-OomKillsMonitor::OomKillsMonitor()
-    : worker_pool_(
-          new SequencedWorkerPool(1, "oom_kills_monitor")) {}
-
-OomKillsMonitor::~OomKillsMonitor() {
-  Stop();
-}
-
-void OomKillsMonitor::Start() {
-  auto task_runner = worker_pool_->GetTaskRunnerWithShutdownBehavior(
-      SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
-  task_runner->PostTask(
-      FROM_HERE, base::Bind(&OomKillsMonitor::Run, worker_pool_));
-}
-
-void OomKillsMonitor::Stop() {
-  worker_pool_->Shutdown();
-}
-
 namespace {
 
 int64_t GetTimestamp(const StringPiece& line) {
   std::vector<StringPiece> fields = base::SplitStringPiece(
       line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   int64_t timestamp = -1;
   // Timestamp is the third field in a line of /dev/kmsg.
   if (fields.size() < 3 || !base::StringToInt64(fields[2], &timestamp))
     return -1;
@@ skipping 82 matching lines @@
 
     if (GetTimeDelta(line, &last_timestamp, &time_delta)) {
       UMA_HISTOGRAM_OOM_KILL_TIME_INTERVAL(
           "Arc.LowMemoryKiller.TimeDelta", time_delta);
     }
   }
 }
 
 }  // namespace
 
+OomKillsMonitor::Handle::Handle(OomKillsMonitor* outer) : outer_(outer) {
+  DCHECK(outer_);
+}
+
+OomKillsMonitor::Handle::~Handle() {
+  outer_->is_shutting_down_.Set();
+}
+
+OomKillsMonitor::OomKillsMonitor() {
+  base::SimpleThread::Options non_joinable_options;
+  non_joinable_options.joinable = false;
+  non_joinable_worker_thread_ = base::WrapUnique(new base::DelegateSimpleThread(

[Luis Héctor Chávez, 2016/08/08 14:29:33]

nit: base::MakeUnique<base::DelegateSimpleThread>(...)

[gab, 2016/08/09 23:05:20]

Nice, didn't know about MakeUnique, thanks!

+      this, "oom_kills_monitor", non_joinable_options));
+  non_joinable_worker_thread_->Start();
+}
+
+OomKillsMonitor::~OomKillsMonitor() {
+  // The instance has to be leaked on shutdown as it is referred to by a
+  // non-joinable thread but ~OomKillsMonitor() can't be explicitly deleted as
+  // it overrides ~SimpleThread(), it should nevertheless never be invoked.
+  NOTREACHED();
+}
+
 // static
-void OomKillsMonitor::Run(
-    scoped_refptr<base::SequencedWorkerPool> worker_pool) {
+OomKillsMonitor::Handle OomKillsMonitor::StartMonitoring() {
+#if DCHECK_IS_ON()
+  static volatile bool monitoring_active = false;
+  DCHECK(!monitoring_active);
+  monitoring_active = true;
+#endif
+
+  // Instantiate the OomKillsMonitor and its underlying thread. The
+  // OomKillsMonitor itself has to be leaked on shutdown per having a
+  // non-joinable thread associated to its state. The OomKillsMonitor::Handle
+  // will notify the OomKillsMonitor when it is destroyed so that the underlying
+  // thread can at a minimum not do extra work during shutdown.
+  OomKillsMonitor* instance = new OomKillsMonitor;
+  ANNOTATE_LEAKING_OBJECT_PTR(instance);
+  return Handle(instance);
+}
+
+void OomKillsMonitor::Run() {
   base::ScopedFILE kmsg_handle(
       base::OpenFile(base::FilePath("/dev/kmsg"), "r"));
   if (!kmsg_handle) {
     LOG(WARNING) << "Open /dev/kmsg failed: " << base::safe_strerror(errno);
     return;
   }
   // Skip kernel messages prior to the instantiation of this object to avoid
   // double reporting.
   fseek(kmsg_handle.get(), 0, SEEK_END);
 
   static const int kMaxBufSize = 512;
   char buf[kMaxBufSize];
 
   while (fgets(buf, kMaxBufSize, kmsg_handle.get())) {
-    if (worker_pool->IsShutdownInProgress()) {
+    if (is_shutting_down_.IsSet()) {
       DVLOG(1) << "Chrome is shutting down, exit now.";
       break;
     }
     const StringPiece buf_string(buf);
     LogOOMKill(buf_string);
     LogLowMemoryKill(buf_string);
   }
 }
 
 }  // namespace arc