NetLogEventParameter to Callback refactoring 8.

net/base/file_stream_win.cc

 // Copyright (c) 2012 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 59 matching lines @@
       NetLog::StringCallback("file_name", &file_name));
 
   *file = base::CreatePlatformFile(path, open_flags, NULL, NULL);
   if (*file == base::kInvalidPlatformFileValue) {
     DWORD error = GetLastError();
     LOG(WARNING) << "Failed to open file: " << error;
     *result = RecordAndMapError(error,
                                 FILE_ERROR_SOURCE_OPEN,
                                 record_uma,
                                 bound_net_log);
-    bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN, NULL);
+    bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
     return;
   }
 }
 
 // Closes a file with some network logging.
 void CloseFile(base::PlatformFile file,
                const net::BoundNetLog& bound_net_log) {
-  bound_net_log.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE, NULL);
+  bound_net_log.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE);
   if (file == base::kInvalidPlatformFileValue)
     return;
 
   CancelIo(file);
 
   if (!base::ClosePlatformFile(file))
     NOTREACHED();
-  bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN, NULL);
+  bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
 }
 
 // Closes a file with CloseFile() and signals the completion.
 void CloseFileAndSignal(base::PlatformFile* file,
                         base::WaitableEvent* on_io_complete,
                         const net::BoundNetLog& bound_net_log) {
   CloseFile(*file, bound_net_log);
   *file = base::kInvalidPlatformFileValue;
   on_io_complete->Signal();
 }
@@ skipping 97 matching lines @@
 // FileStream ------------------------------------------------------------
 
 FileStreamWin::FileStreamWin(net::NetLog* net_log)
     : file_(base::kInvalidPlatformFileValue),
       open_flags_(0),
       auto_closed_(true),
       record_uma_(false),
       bound_net_log_(net::BoundNetLog::Make(net_log,
                                             net::NetLog::SOURCE_FILESTREAM)),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE, NULL);
+  bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
 }
 
 FileStreamWin::FileStreamWin(
     base::PlatformFile file, int flags, net::NetLog* net_log)
     : file_(file),
       open_flags_(flags),
       auto_closed_(false),
       record_uma_(false),
       bound_net_log_(net::BoundNetLog::Make(net_log,
                                             net::NetLog::SOURCE_FILESTREAM)),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE, NULL);
+  bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
 
   // 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(bound_net_log_));
     MessageLoopForIO::current()->RegisterIOHandler(file_,
                                                    async_context_.get());
   }
 }
 
@@ skipping 15 matching lines @@
             FROM_HERE,
             base::Bind(&CloseFile, file_, bound_net_log_),
             true /* task_is_slow */);
         DCHECK(posted);
       }
     } else {
       CloseSync();
     }
   }
 
-  bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE, NULL);
+  bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
 }
 
 void FileStreamWin::Close(const CompletionCallback& callback) {
   DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
   DCHECK(!on_io_complete_.get());
   on_io_complete_.reset(new base::WaitableEvent(
       false  /* manual_reset */, false  /* initially_signaled */));
 
   // Passing &file_ to a thread pool looks unsafe but it's safe here as the
@@ skipping 12 matching lines @@
 
 void FileStreamWin::CloseSync() {
   // The logic here is similar to CloseFile() but async_context_.reset() is
   // caled in this function.
 
   // Block until the in-flight open operation is complete.
   // TODO(satorux): Replace this with a DCHECK(open_flags & ASYNC) once this
   // once all async clients are migrated to use Close(). crbug.com/114783
   WaitForIOCompletion();
 
-  bound_net_log_.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE, NULL);
+  bound_net_log_.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE);
   if (file_ != base::kInvalidPlatformFileValue)
     CancelIo(file_);
 
   // Block until the last read/write operation is complete.
   async_context_.reset();
 
   if (file_ != base::kInvalidPlatformFileValue) {
     if (!base::ClosePlatformFile(file_))
       NOTREACHED();
     file_ = base::kInvalidPlatformFileValue;
 
-    bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN, NULL);
+    bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
   }
 }
 
 int FileStreamWin::Open(const FilePath& path, int open_flags,
                         const CompletionCallback& callback) {
   if (IsOpen()) {
     DLOG(FATAL) << "File is already open!";
     return ERR_UNEXPECTED;
   }
 
@@ skipping 404 matching lines @@
 void FileStreamWin::WaitForIOCompletion() {
   // http://crbug.com/115067
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   if (on_io_complete_.get()) {
     on_io_complete_->Wait();
     on_io_complete_.reset();
   }
 }
 
 }  // namespace net