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 39 matching lines @@
                FROM_END     == SEEK_END, whence_matches_system);
 
 namespace {
 
 int RecordAndMapError(int error,
                       FileErrorSource source,
                       bool record_uma,
                       const net::BoundNetLog& bound_net_log) {
   net::Error net_error = MapSystemError(error);
 
+  std::string error_name = GetFileErrorSourceName(source);

[eroman, 2012/06/11 23:42:25]

Not a big deal either way since this is an error logging, but how about passing
in &source to NetLogFileStreamErrorCallback instead. And then having that guy do
the stringizing.

[mmenke, 2012/06/12 00:42:19]

Done.

   bound_net_log.AddEvent(
       net::NetLog::TYPE_FILE_STREAM_ERROR,
-      make_scoped_refptr(
-          new FileStreamErrorParameters(GetFileErrorSourceName(source),
-                                        error,
-                                        net_error)));
+      base::Bind(&NetLogFileStreamErrorCallback,
+                 &error_name, 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));

[eroman, 2012/06/11 23:42:25]

Can you take address to to path.AsUTF8Unsafe() directly as a temporary? (Or does
the compiler barf?)

[mmenke, 2012/06/12 00:42:19]

The compiler doesn't barf.

I had assumed temporaries were discarded when the function they were passed to
returned.  Looks like I was wrong, and they're discarded only after evaluation
of the entire expression.  Shockingly, it's never an issue I've had to care
about before.

[mmenke, 2012/06/12 00:50:58]

Correction...MSVC doesn't barf, and the string appears to be valid long enough,
but clang *does* barf.  Undone.

 
   *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