Add uma stats to help evaluate the impact of changes to the quota allocation logic.

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "third_party/leveldatabase/env_chromium.h"
 
 #include <utility>
 
 #if defined(OS_POSIX)
 #include <dirent.h>
 #include <sys/types.h>
 #endif
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_functions.h"
 #include "base/process/process_metrics.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/leveldatabase/chromium_logger.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/re2/src/re2/re2.h"
@@ skipping 66 matching lines @@
     result->push_back(FilePath::FromUTF8Unsafe(dent->d_name));
   }
   int saved_errno = errno;
   closedir(dir);
   if (readdir_result != 0)
     return base::File::OSErrorToFileError(saved_errno);
   return base::File::FILE_OK;
 #endif
 }
 
+// To avoid a dependency on storage_histograms.h and the storageLib,
+// we re-implement the BytesCountHistogram functions here.
+void RecordStorageBytesWritten(const char* label, int amount) {
+  const std::string name = "Storage.BytesWritten.";
+  base::UmaHistogramCounts10M(name + label, amount);
+}
+
+void RecordStorageBytesRead(const char* label, int amount) {
+  const std::string name = "Storage.BytesRead.";
+  base::UmaHistogramCounts10M(name + label, amount);
+}
+
 class ChromiumFileLock : public FileLock {
  public:
   ChromiumFileLock(base::File file, const std::string& name)
       : file_(std::move(file)), name_(name) {}
 
   base::File file_;
   std::string name_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromiumFileLock);
@@ skipping 54 matching lines @@
   virtual ~ChromiumSequentialFile() {}
 
   Status Read(size_t n, Slice* result, char* scratch) override {
     TRACE_EVENT1("leveldb", "ChromiumSequentialFile::Read", "size", n);
     int bytes_read = file_.ReadAtCurrentPosNoBestEffort(scratch, n);
     if (bytes_read == -1) {
       base::File::Error error = LastFileError();
       uma_logger_->RecordErrorAt(kSequentialFileRead);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          kSequentialFileRead, error);
-    } else {
-      *result = Slice(scratch, bytes_read);
-      return Status::OK();
     }
+    if (bytes_read > 0)
+      uma_logger_->RecordBytesRead(bytes_read);
+    *result = Slice(scratch, bytes_read);
+    return Status::OK();
   }
 
   Status Skip(uint64_t n) override {
     if (file_.Seek(base::File::FROM_CURRENT, n) == -1) {
       base::File::Error error = LastFileError();
       uma_logger_->RecordErrorAt(kSequentialFileSkip);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          kSequentialFileSkip, error);
     } else {
       return Status::OK();
@@ skipping 15 matching lines @@
                            const UMALogger* uma_logger)
       : filename_(fname), file_(std::move(file)), uma_logger_(uma_logger) {}
   virtual ~ChromiumRandomAccessFile() {}
 
   Status Read(uint64_t offset,
               size_t n,
               Slice* result,
               char* scratch) const override {
     TRACE_EVENT2("leveldb", "ChromiumRandomAccessFile::Read", "offset", offset,
                  "size", n);
-    Status s;
-    int r = file_.Read(offset, scratch, n);
-    *result = Slice(scratch, (r < 0) ? 0 : r);
-    if (r < 0) {
-      // An error: return a non-ok status
-      s = MakeIOError(filename_, "Could not perform read",
-                      kRandomAccessFileRead);
+    int bytes_read = file_.Read(offset, scratch, n);
+    *result = Slice(scratch, (bytes_read < 0) ? 0 : bytes_read);
+    if (bytes_read < 0) {
       uma_logger_->RecordErrorAt(kRandomAccessFileRead);
+      return MakeIOError(filename_, "Could not perform read",
+                         kRandomAccessFileRead);
     }
-    return s;
+    if (bytes_read > 0)
+      uma_logger_->RecordBytesRead(bytes_read);
+    return Status::OK();
   }
 
  private:
   std::string filename_;
   mutable base::File file_;
   const UMALogger* uma_logger_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromiumRandomAccessFile);
 };
 
@@ skipping 58 matching lines @@
 Status ChromiumWritableFile::Append(const Slice& data) {
   DCHECK(file_.IsValid());
   DCHECK(uma_logger_);
   int bytes_written = file_.WriteAtCurrentPos(data.data(), data.size());
   if (bytes_written != data.size()) {
     base::File::Error error = LastFileError();
     uma_logger_->RecordOSError(kWritableFileAppend, error);
     return MakeIOError(filename_, base::File::ErrorToString(error),
                        kWritableFileAppend, error);
   }
-
+  if (bytes_written > 0)
+    uma_logger_->RecordBytesWritten(bytes_written);
   return Status::OK();
 }
 
 Status ChromiumWritableFile::Close() {
   file_.Close();
   return Status::OK();
 }
 
 Status ChromiumWritableFile::Flush() {
   // base::File doesn't do buffered I/O (i.e. POSIX FILE streams) so nothing to
@@ skipping 588 matching lines @@
 
 void ChromiumEnv::SleepForMicroseconds(int micros) {
   // Round up to the next millisecond.
   base::PlatformThread::Sleep(base::TimeDelta::FromMicroseconds(micros));
 }
 
 void ChromiumEnv::RecordErrorAt(MethodID method) const {
   GetMethodIOErrorHistogram()->Add(method);
 }
 
-void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
-  GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
-}
-
 void ChromiumEnv::RecordOSError(MethodID method,
                                 base::File::Error error) const {
   DCHECK_LT(error, 0);
   RecordErrorAt(method);
   GetOSErrorHistogram(method, -base::File::FILE_ERROR_MAX)->Add(-error);
 }
 
+void ChromiumEnv::RecordBytesRead(int amount) const {
+  RecordStorageBytesRead(name_.c_str(), amount);
+}
+
+void ChromiumEnv::RecordBytesWritten(int amount) const {
+  RecordStorageBytesWritten(name_.c_str(), amount);
+}
+
+void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
+  GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
+}
+
 base::HistogramBase* ChromiumEnv::GetOSErrorHistogram(MethodID method,
                                                       int limit) const {
   std::string uma_name;
   base::StringAppendF(&uma_name, "%s.%s", uma_ioerror_base_name_.c_str(),
                       MethodIDToString(method));
   return base::LinearHistogram::FactoryGet(uma_name, 1, limit, limit + 1,
       base::Histogram::kUmaTargetedHistogramFlag);
 }
 
 base::HistogramBase* ChromiumEnv::GetMethodIOErrorHistogram() const {
@@ skipping 137 matching lines @@
 
 }  // namespace leveldb_env
 
 namespace leveldb {
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb