(Finally) Remove NetLog::EventParameters.

net/base/file_stream_posix.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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream.h"
 
 #include <sys/types.h>
@@ skipping 65 matching lines @@
               int* result,
               const net::BoundNetLog& bound_net_log) {
   std::string file_name = path.AsUTF8Unsafe();
   bound_net_log.BeginEvent(
       net::NetLog::TYPE_FILE_STREAM_OPEN,
       NetLog::StringCallback("file_name", &file_name));
 
   *result = OK;
   *file = base::CreatePlatformFile(path, open_flags, NULL, NULL);
   if (*file == base::kInvalidPlatformFileValue) {
-    bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN, NULL);
+    bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
     *result = RecordAndMapError(errno, FILE_ERROR_SOURCE_OPEN, record_uma,
                                 bound_net_log);
   }
 }
 
 // Opens a file using OpenFile() and then signals the completion.
 void OpenFileAndSignal(const FilePath& path,
                        int open_flags,
                        bool record_uma,
                        base::PlatformFile* file,
                        int* result,
                        base::WaitableEvent* on_io_complete,
                        const net::BoundNetLog& bound_net_log) {
   OpenFile(path, open_flags, record_uma, file, result, bound_net_log);
   on_io_complete->Signal();
 }
 
 // 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;
 
   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 126 matching lines @@
 // FileStreamPosix ------------------------------------------------------------
 
 FileStreamPosix::FileStreamPosix(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);
 }
 
 FileStreamPosix::FileStreamPosix(
     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);
 }
 
 FileStreamPosix::~FileStreamPosix() {
   if (open_flags_ & base::PLATFORM_FILE_ASYNC) {
     // Block until the last open/close/read/write operation is complete.
     // TODO(satorux): Ideally we should not block. crbug.com/115067
     WaitForIOCompletion();
   }
 
   if (auto_closed_) {
     if (open_flags_ & base::PLATFORM_FILE_ASYNC) {
       // Close the file in the background.
       if (IsOpen()) {
         const bool posted = base::WorkerPool::PostTask(
             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 FileStreamPosix::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 */));
 
@@ skipping 331 matching lines @@
 void FileStreamPosix::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