Return unique_ptrs from base::ProcessMetrics.

base/process/process_metrics_linux.cc

 // Copyright (c) 2013 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 "base/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <utility>
 
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/process/internal_linux.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 
 namespace base {
@@ skipping 35 matching lines @@
       return 0;
   }
 
   StringPairs pairs;
   SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
   TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::string& key = pairs[i].first;
     const std::string& value_str = pairs[i].second;
     if (key == field) {
-      std::vector<StringPiece> split_value_str = SplitStringPiece(
-          value_str, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      std::vector<StringPiece> split_value_str =
+          SplitStringPiece(value_str, " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
       if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
         NOTREACHED();
         return 0;
       }
       size_t value;
       if (!StringToSizeT(split_value_str[0], &value)) {
         NOTREACHED();
         return 0;
       }
       return value;
@@ skipping 69 matching lines @@
     }
   }
   closedir(dir);
 
   return total_cpu;
 }
 
 }  // namespace
 
 // static
-ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
-  return new ProcessMetrics(process);
+std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
+    ProcessHandle process) {
+  return WrapUnique(new ProcessMetrics(process));

[Lei Zhang, 2016/07/25 17:28:20]

dcheng: Any suggestions on how to better handle private ctors?

 }
 
 // On linux, we return vsize.
 size_t ProcessMetrics::GetPagefileUsage() const {
   return internal::ReadProcStatsAndGetFieldAsSizeT(process_,
                                                    internal::VM_VSIZE);
 }
 
 // On linux, we return the high water mark of vsize.
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
@@ skipping 169 matching lines @@
   std::string totmaps_data;
   {
     FilePath totmaps_file = internal::GetProcPidDir(process_).Append("totmaps");
     ThreadRestrictions::ScopedAllowIO allow_io;
     bool ret = ReadFileToString(totmaps_file, &totmaps_data);
     if (!ret || totmaps_data.length() == 0)
       return false;
   }
 
   std::vector<std::string> totmaps_fields = SplitString(
-      totmaps_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
-      base::SPLIT_WANT_NONEMPTY);
+      totmaps_data, kWhitespaceASCII, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
 
   DCHECK_EQ("Pss:", totmaps_fields[kPssIndex-1]);
   DCHECK_EQ("Private_Clean:", totmaps_fields[kPrivate_CleanIndex - 1]);
   DCHECK_EQ("Private_Dirty:", totmaps_fields[kPrivate_DirtyIndex - 1]);
   DCHECK_EQ("Swap:", totmaps_fields[kSwapIndex-1]);
 
   int pss = 0;
   int private_clean = 0;
   int private_dirty = 0;
   int swap = 0;
@@ skipping 30 matching lines @@
   std::string statm;
   {
     FilePath statm_file = internal::GetProcPidDir(process_).Append("statm");
     // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
     bool ret = ReadFileToString(statm_file, &statm);
     if (!ret || statm.length() == 0)
       return false;
   }
 
-  std::vector<StringPiece> statm_vec = SplitStringPiece(
-      statm, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<StringPiece> statm_vec =
+      SplitStringPiece(statm, " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
   if (statm_vec.size() != 7)
     return false;  // Not the format we expect.
 
   int statm_rss, statm_shared;
   bool ret = true;
   ret &= StringToInt(statm_vec[1], &statm_rss);
   ret &= StringToInt(statm_vec[2], &statm_shared);
 
   ws_usage->priv = (statm_rss - statm_shared) * page_size_kb;
   ws_usage->shared = statm_shared * page_size_kb;
@@ skipping 536 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64_t wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base