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

components/leveldb/env_mojo.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/leveldb/env_mojo.h"
 
 #include <errno.h>
 
 #include <memory>
 
@@ skipping 66 matching lines @@
 
   Status Read(size_t n, Slice* result, char* scratch) override {
     int bytes_read = file_.ReadAtCurrentPosNoBestEffort(
         scratch,
         static_cast<int>(n));
     if (bytes_read == -1) {
       base::File::Error error = LastFileError();
       uma_logger_->RecordOSError(leveldb_env::kSequentialFileRead, error);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          leveldb_env::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_->RecordOSError(leveldb_env::kSequentialFileSkip, error);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          leveldb_env::kSequentialFileSkip, error);
     } else {
       return Status::OK();
@@ skipping 13 matching lines @@
   MojoRandomAccessFile(const std::string& fname,
                        base::File file,
                        const UMALogger* uma_logger)
       : filename_(fname), file_(std::move(file)), uma_logger_(uma_logger) {}
   ~MojoRandomAccessFile() override {}
 
   Status Read(uint64_t offset,
               size_t n,
               Slice* result,
               char* scratch) const override {
-    Status s;
-    int r = file_.Read(offset, scratch, static_cast<int>(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",
-                      leveldb_env::kRandomAccessFileRead);
+    int bytes_read = file_.Read(offset, scratch, static_cast<int>(n));
+    *result = Slice(scratch, (bytes_read < 0) ? 0 : bytes_read);
+    if (bytes_read < 0) {
       uma_logger_->RecordOSError(leveldb_env::kRandomAccessFileRead,
                                  LastFileError());
+      return MakeIOError(filename_, "Could not perform read",
+                         leveldb_env::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(MojoRandomAccessFile);
 };
 
@@ skipping 17 matching lines @@
     } else if (path.MatchesExtension(table_extension)) {
       file_type_ = kTable;
     }
     parent_dir_ =
         base::FilePath::FromUTF8Unsafe(fname).DirName().AsUTF8Unsafe();
   }
 
   ~MojoWritableFile() override {}
 
   leveldb::Status Append(const leveldb::Slice& data) override {
-    size_t bytes_written = file_.WriteAtCurrentPos(
-        data.data(), static_cast<int>(data.size()));
-    if (bytes_written != data.size()) {
+    int bytes_written =
+        file_.WriteAtCurrentPos(data.data(), static_cast<int>(data.size()));
+    if (bytes_written != static_cast<int>(data.size())) {
       base::File::Error error = LastFileError();
       uma_logger_->RecordOSError(leveldb_env::kWritableFileAppend, error);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          leveldb_env::kWritableFileAppend, error);
     }
-
+    if (bytes_written > 0)
+      uma_logger_->RecordBytesWritten(bytes_written);
     return Status::OK();
   }
 
   leveldb::Status Close() override {
     file_.Close();
     return Status::OK();
   }
 
   leveldb::Status Flush() override {
     // base::File doesn't do buffered I/O (i.e. POSIX FILE streams) so nothing
-    // to
-    // flush.
+    // to flush.
     return Status::OK();
   }
 
   leveldb::Status Sync() override {
     TRACE_EVENT0("leveldb", "MojoWritableFile::Sync");
 
     if (!file_.Flush()) {
       base::File::Error error = LastFileError();
       uma_logger_->RecordOSError(leveldb_env::kWritableFileSync, error);
       return MakeIOError(filename_, base::File::ErrorToString(error),
@@ skipping 245 matching lines @@
 }
 
 void MojoEnv::RecordOSError(leveldb_env::MethodID method,
                             base::File::Error error) const {
   RecordErrorAt(method);
   std::string uma_name =
       std::string("MojoLevelDBEnv.IOError.BFE.") + MethodIDToString(method);
   base::UmaHistogramExactLinear(uma_name, -error, -base::File::FILE_ERROR_MAX);
 }
 
+void MojoEnv::RecordBytesRead(int amount) const {
+  UMA_HISTOGRAM_COUNTS_10M("Storage.BytesRead.MojoLevelDBEnv", amount);
+}
+
+void MojoEnv::RecordBytesWritten(int amount) const {
+  UMA_HISTOGRAM_COUNTS_10M("Storage.BytesWritten.MojoLevelDBEnv", amount);
+}
+
 void MojoEnv::RecordFileError(leveldb_env::MethodID method,
                               FileError error) const {
   RecordOSError(method, static_cast<base::File::Error>(error));
 }
 
 uint64_t MojoEnv::NowMicros() {
   return base::TimeTicks::Now().ToInternalValue();
 }
 
 void MojoEnv::SleepForMicroseconds(int micros) {
   // Round up to the next millisecond.
   base::PlatformThread::Sleep(base::TimeDelta::FromMicroseconds(micros));
 }
 
 void MojoEnv::Schedule(void (*function)(void* arg), void* arg) {
   base::PostTaskWithTraits(FROM_HERE,
                            {base::MayBlock(), base::WithBaseSyncPrimitives(),
                             base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
                            base::Bind(function, arg));
 }
 
 void MojoEnv::StartThread(void (*function)(void* arg), void* arg) {
   new Thread(function, arg);  // Will self-delete.
 }
 
 }  // namespace leveldb