NetLogEventParameter to Callback refactoring 1,

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 41 matching lines @@
 namespace {
 
 int RecordAndMapError(int error,
                       FileErrorSource source,
                       bool record_uma,
                       const net::BoundNetLog& bound_net_log) {
   net::Error net_error = MapSystemError(error);
 
   bound_net_log.AddEvent(
       net::NetLog::TYPE_FILE_STREAM_ERROR,
-      make_scoped_refptr(
-          new FileStreamErrorParameters(GetFileErrorSourceName(source),
-                                        error,
-                                        net_error)));
+      base::Bind(&NetLogFileStreamErrorCallback,
+                 source, error, net_error));
 
   RecordFileError(error, source, record_uma);
 
   return net_error;
 }
 
 // Opens a file with some network logging.
 // The opened file and the result code are written to |file| and |result|.
 void OpenFile(const FilePath& path,
               int open_flags,
               bool record_uma,
               base::PlatformFile* file,
               int* result,
               const net::BoundNetLog& bound_net_log) {
+  std::string file_name = path.AsUTF8Unsafe();
   bound_net_log.BeginEvent(
       net::NetLog::TYPE_FILE_STREAM_OPEN,
-      make_scoped_refptr(
-          new net::NetLogStringParameter("file_name",
-                                         path.AsUTF8Unsafe())));
+      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);
     *result = RecordAndMapError(errno, FILE_ERROR_SOURCE_OPEN, record_uma,
                                 bound_net_log);
   }
 }
 
@@ skipping 513 matching lines @@
       (bound_net_log_.source().id == net::NetLog::Source::kInvalidId)) {
     // Both |BoundNetLog|s are invalid.
     return;
   }
 
   // Should never connect to itself.
   DCHECK_NE(bound_net_log_.source().id, owner_bound_net_log.source().id);
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_FILE_STREAM_BOUND_TO_OWNER,
-      make_scoped_refptr(
-          new net::NetLogSourceParameter("source_dependency",
-                                         owner_bound_net_log.source())));
+      owner_bound_net_log.source().ToEventParametersCallback());
 
   owner_bound_net_log.AddEvent(
       net::NetLog::TYPE_FILE_STREAM_SOURCE,
-      make_scoped_refptr(
-          new net::NetLogSourceParameter("source_dependency",
-                                         bound_net_log_.source())));
+      bound_net_log_.source().ToEventParametersCallback());
 }
 
 base::PlatformFile FileStreamPosix::GetPlatformFileForTesting() {
   return file_;
 }
 
 void FileStreamPosix::ResetOnIOComplete() {
   on_io_complete_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void FileStreamPosix::OnClosed(const CompletionCallback& callback) {
   file_ = base::kInvalidPlatformFileValue;
 
   // Reset this before Run() as Run() may issue a new async operation.
   ResetOnIOComplete();
   callback.Run(OK);
 }
 
 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