Record UMA statistics for file_stream operations.

net/base/file_stream_win.cc

 // Copyright (c) 2011 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 "net/base/file_stream.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
     default:
       LOG(WARNING) << "Unknown error " << err << " mapped to net::ERR_FAILED";
       return ERR_FAILED;
   }
 }
 
 // FileStream::AsyncContext ----------------------------------------------
 
 class FileStream::AsyncContext : public MessageLoopForIO::IOHandler {
  public:
-  AsyncContext(FileStream* owner)
-      : owner_(owner), context_(), callback_(NULL), is_closing_(false) {
+  AsyncContext(FileStream* owner, int class_flags)
+      : owner_(owner), context_(), callback_(NULL), is_closing_(false),
+        class_flags_(class_flags) {
     context_.handler = this;
   }
   ~AsyncContext();
 
   void IOCompletionIsPending(CompletionCallback* callback);
 
   OVERLAPPED* overlapped() { return &context_.overlapped; }
   CompletionCallback* callback() const { return callback_; }
 
+  void EnableRecording(bool enable, int class_flags) {
+    if (enable)
+      class_flags_ |= class_flags;
+    else
+      class_flags_ &= ~class_flags;
+  }
+
  private:
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_read, DWORD error);
 
   FileStream* owner_;
   MessageLoopForIO::IOContext context_;
   CompletionCallback* callback_;
   bool is_closing_;
+  int class_flags_;
 };
 
 FileStream::AsyncContext::~AsyncContext() {
   is_closing_ = true;
   bool waited = false;
   base::TimeTicks start = base::TimeTicks::Now();
   while (callback_) {
     waited = true;
     MessageLoopForIO::current()->WaitForIOCompletion(INFINITE, this);
   }
@@ skipping 14 matching lines @@
     MessageLoopForIO::IOContext* context, DWORD bytes_read, DWORD error) {
   DCHECK_EQ(&context_, context);
   DCHECK(callback_);
 
   if (is_closing_) {
     callback_ = NULL;
     return;
   }
 
   int result = static_cast<int>(bytes_read);
-  if (error && error != ERROR_HANDLE_EOF)
+  if (error && error != ERROR_HANDLE_EOF) {
+    RecordFileError(error, FILE_ERROR_TYPES_READ, class_flags_);
     result = MapErrorCode(error);
+  }
 
   if (bytes_read)
     IncrementOffset(&context->overlapped, bytes_read);
 
   CompletionCallback* temp = NULL;
   std::swap(temp, callback_);
   temp->Run(result);
 }
 
 // FileStream ------------------------------------------------------------
 
 FileStream::FileStream()
     : file_(INVALID_HANDLE_VALUE),
       open_flags_(0),
-      auto_closed_(true) {
+      auto_closed_(true),
+      class_flags_(0) {
+}
+
+FileStream::FileStream(int class_flags)
+    : file_(INVALID_HANDLE_VALUE),
+      open_flags_(0),
+      auto_closed_(true),
+      class_flags_(class_flags) {
 }
 
 FileStream::FileStream(base::PlatformFile file, int flags)
     : file_(file),
       open_flags_(flags),
-      auto_closed_(false) {
+      auto_closed_(false),
+      class_flags_(0) {
   // If the file handle is opened with base::PLATFORM_FILE_ASYNC, we need to
   // make sure we will perform asynchronous File IO to it.
   if (flags & base::PLATFORM_FILE_ASYNC) {
-    async_context_.reset(new AsyncContext(this));
+    async_context_.reset(new AsyncContext(this, class_flags_));
     MessageLoopForIO::current()->RegisterIOHandler(file_,
                                                    async_context_.get());
   }
+}
+
+FileStream::FileStream(base::PlatformFile file, int flags, int class_flags)
+    : file_(file),
+      open_flags_(flags),
+      auto_closed_(false),
+      class_flags_(class_flags) {
+  // If the file handle is opened with base::PLATFORM_FILE_ASYNC, we need to
+  // make sure we will perform asynchronous File IO to it.
+  if (flags & base::PLATFORM_FILE_ASYNC) {
+    async_context_.reset(new AsyncContext(this, class_flags_));
+    MessageLoopForIO::current()->RegisterIOHandler(file_,
+                                                   async_context_.get());
+  }
 }
 
 FileStream::~FileStream() {
   if (auto_closed_)
     Close();
 }
 
 void FileStream::Close() {
   if (file_ != INVALID_HANDLE_VALUE)
     CancelIo(file_);
 
   async_context_.reset();
   if (file_ != INVALID_HANDLE_VALUE) {
     CloseHandle(file_);
     file_ = INVALID_HANDLE_VALUE;
   }
 }
 
 int FileStream::Open(const FilePath& path, int open_flags) {
   if (IsOpen()) {
     DLOG(FATAL) << "File is already open!";
     return ERR_UNEXPECTED;
   }
 
   open_flags_ = open_flags;
   file_ = base::CreatePlatformFile(path, open_flags_, NULL, NULL);
   if (file_ == INVALID_HANDLE_VALUE) {
     DWORD error = GetLastError();
     LOG(WARNING) << "Failed to open file: " << error;
+    RecordFileError(error, FILE_ERROR_TYPES_OPEN, class_flags_);
     return MapErrorCode(error);
   }
 
   if (open_flags_ & base::PLATFORM_FILE_ASYNC) {
-    async_context_.reset(new AsyncContext(this));
+    async_context_.reset(new AsyncContext(this, class_flags_));
     MessageLoopForIO::current()->RegisterIOHandler(file_,
                                                    async_context_.get());
   }
 
   return OK;
 }
 
 bool FileStream::IsOpen() const {
   return file_ != INVALID_HANDLE_VALUE;
 }
 
 int64 FileStream::Seek(Whence whence, int64 offset) {
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
+
   DCHECK(!async_context_.get() || !async_context_->callback());
 
   LARGE_INTEGER distance, result;
   distance.QuadPart = offset;
   DWORD move_method = static_cast<DWORD>(whence);
   if (!SetFilePointerEx(file_, distance, &result, move_method)) {
     DWORD error = GetLastError();
     LOG(WARNING) << "SetFilePointerEx failed: " << error;
+    RecordFileError(error, FILE_ERROR_TYPES_SEEK, class_flags_);
     return MapErrorCode(error);
   }
   if (async_context_.get())
     SetOffset(async_context_->overlapped(), result);
   return result.QuadPart;
 }
 
 int64 FileStream::Available() {
   base::ThreadRestrictions::AssertIOAllowed();
 
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
 
   int64 cur_pos = Seek(FROM_CURRENT, 0);
   if (cur_pos < 0)
     return cur_pos;
 
   LARGE_INTEGER file_size;
   if (!GetFileSizeEx(file_, &file_size)) {
     DWORD error = GetLastError();
     LOG(WARNING) << "GetFileSizeEx failed: " << error;
+    RecordFileError(error, FILE_ERROR_TYPES_GET_SIZE, class_flags_);
     return MapErrorCode(error);
   }
 
   return file_size.QuadPart - cur_pos;
 }
 
 int FileStream::Read(
     char* buf, int buf_len, CompletionCallback* callback) {
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
+
   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 
   OVERLAPPED* overlapped = NULL;
   if (async_context_.get()) {
     DCHECK(callback);
     DCHECK(!async_context_->callback());
     overlapped = async_context_->overlapped();
   } else {
     DCHECK(!callback);
     base::ThreadRestrictions::AssertIOAllowed();
   }
 
   int rv;
 
   DWORD bytes_read;
   if (!ReadFile(file_, buf, buf_len, &bytes_read, overlapped)) {
     DWORD error = GetLastError();
     if (async_context_.get() && error == ERROR_IO_PENDING) {
       async_context_->IOCompletionIsPending(callback);
       rv = ERR_IO_PENDING;
     } else if (error == ERROR_HANDLE_EOF) {
       rv = 0;  // Report EOF by returning 0 bytes read.
     } else {
       LOG(WARNING) << "ReadFile failed: " << error;
+      RecordFileError(error, FILE_ERROR_TYPES_READ, class_flags_);
       rv = MapErrorCode(error);
     }
   } else if (overlapped) {
     async_context_->IOCompletionIsPending(callback);
     rv = ERR_IO_PENDING;
   } else {
     rv = static_cast<int>(bytes_read);
   }
   return rv;
 }
@@ skipping 14 matching lines @@
     bytes_total += bytes_read;
     buf += bytes_read;
     to_read -= bytes_read;
   } while (bytes_total < buf_len);
 
   return bytes_total;
 }
 
 int FileStream::Write(
     const char* buf, int buf_len, CompletionCallback* callback) {
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 
   OVERLAPPED* overlapped = NULL;
   if (async_context_.get()) {
     DCHECK(callback);
     DCHECK(!async_context_->callback());
     overlapped = async_context_->overlapped();
   } else {
     DCHECK(!callback);
     base::ThreadRestrictions::AssertIOAllowed();
   }
 
   int rv;
   DWORD bytes_written;
   if (!WriteFile(file_, buf, buf_len, &bytes_written, overlapped)) {
     DWORD error = GetLastError();
     if (async_context_.get() && error == ERROR_IO_PENDING) {
       async_context_->IOCompletionIsPending(callback);
       rv = ERR_IO_PENDING;
     } else {
       LOG(WARNING) << "WriteFile failed: " << error;
+      RecordFileError(error, FILE_ERROR_TYPES_WRITE, class_flags_);
       rv = MapErrorCode(error);
     }
   } else if (overlapped) {
     async_context_->IOCompletionIsPending(callback);
     rv = ERR_IO_PENDING;
   } else {
     rv = static_cast<int>(bytes_written);
   }
   return rv;
 }
 
 int FileStream::Flush() {
   base::ThreadRestrictions::AssertIOAllowed();
 
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
   if (FlushFileBuffers(file_)) {
     return OK;
   }
 
   int rv;
   DWORD error = GetLastError();
+  RecordFileError(error, FILE_ERROR_TYPES_FLUSH, class_flags_);
   rv = MapErrorCode(error);
   return rv;
 }
 
 int64 FileStream::Truncate(int64 bytes) {
   base::ThreadRestrictions::AssertIOAllowed();
 
-  if (!IsOpen())
+  if (!IsOpen()) {
+    RecordFileError(ERROR_INVALID_HANDLE, FILE_ERROR_TYPES_IS_NOT_OPEN,
+                    class_flags_);
     return ERR_UNEXPECTED;
+  }
 
   // We better be open for reading.
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 
   // Seek to the position to truncate from.
   int64 seek_position = Seek(FROM_BEGIN, bytes);
   if (seek_position != bytes)
     return ERR_UNEXPECTED;
 
   // And truncate the file.
   BOOL result = SetEndOfFile(file_);
   if (!result) {
     DWORD error = GetLastError();
     LOG(WARNING) << "SetEndOfFile failed: " << error;
+    RecordFileError(error, FILE_ERROR_TYPES_SET_EOF, class_flags_);
     return MapErrorCode(error);
   }
 
   // Success.
   return seek_position;
 }
 
+void FileStream::EnableRecording(bool enable, int class_flags) {
+  if (enable)
+    class_flags_ |= class_flags;
+  else
+    class_flags_ &= ~class_flags;
+
+  if (async_context_.get())
+    async_context_->EnableRecording(enable, class_flags);
+}
+
 }  // namespace net