Add ability for NetLogLogger to gather data from more than just NetLog

chrome/browser/extensions/api/log_private/log_private_api_chromeos.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/log_private/log_private_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 236 matching lines @@
     // Create the event's arguments value.
     scoped_ptr<base::ListValue> event_args(new base::ListValue());
     event_args->Append(value->DeepCopy());
     scoped_ptr<Event> event(
         new Event(events::kOnCapturedEvents, event_args.Pass()));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(*ix, event.Pass());
   }
 }
 
-void LogPrivateAPI::InitializeNetLogger(const std::string& owner_extension_id,
-                                        net::NetLogLogger** net_log_logger) {
+void LogPrivateAPI::CreateFileForNetLogger(
+    const std::string& owner_extension_id,
+    base::ScopedFILE* file) {
   DCHECK(IsRunningOnSequenceThread());
-  (*net_log_logger) = NULL;
 
   // Create app-specific subdirectory in session logs folder.
   base::FilePath app_log_dir = GetAppLogDirectory().Append(owner_extension_id);
   if (!base::DirectoryExists(app_log_dir)) {
     if (!base::CreateDirectory(app_log_dir)) {
       LOG(ERROR) << "Could not create dir " << app_log_dir.value();
       return;
     }
   }
 
   base::FilePath file_path = app_log_dir.Append(kLogFileNameBase);
   file_path = logging::GenerateTimestampedName(file_path, base::Time::Now());
-  FILE* file = NULL;
-  file = fopen(file_path.value().c_str(), "w");
-  if (file == NULL) {
+  FILE* file_ptr = fopen(file_path.value().c_str(), "w");
+  if (file_ptr == nullptr) {
     LOG(ERROR) << "Could not open " << file_path.value();
     return;
   }
 
   RegisterTempFile(owner_extension_id, file_path);
-  scoped_ptr<base::Value> constants(net::NetLogLogger::GetConstants());
-  *net_log_logger = new net::NetLogLogger(file, *constants);
-  (*net_log_logger)->set_log_level(net::NetLog::LOG_ALL_BUT_BYTES);
+  return file->reset(file_ptr);
 }
 
 void LogPrivateAPI::StartObservingNetEvents(
     IOThread* io_thread,
-    net::NetLogLogger** net_log_logger) {
+    base::ScopedFILE* file) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!(*net_log_logger))
+  if (!file->get())
     return;
 
-  net_log_logger_.reset(*net_log_logger);
-  net_log_logger_->StartObserving(io_thread->net_log());
+  net_log_logger_.reset(new net::NetLogLogger());
+  net_log_logger_->set_log_level(net::NetLog::LOG_ALL_BUT_BYTES);
+  net_log_logger_->StartObserving(io_thread->net_log(), file->Pass(), nullptr,
+                                  nullptr);
 }
 
 void LogPrivateAPI::MaybeStartNetInternalLogging(
     const std::string& caller_extension_id,
     IOThread* io_thread,
     api::log_private::EventSink event_sink) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!logging_net_internals_) {
     logging_net_internals_ = true;
     event_sink_ = event_sink;
     switch (event_sink_) {
       case api::log_private::EVENT_SINK_CAPTURE: {
         io_thread->net_log()->AddThreadSafeObserver(
             this, net::NetLog::LOG_ALL_BUT_BYTES);
         break;
       }
       case api::log_private::EVENT_SINK_FILE: {
-        net::NetLogLogger** net_logger_ptr = new net::NetLogLogger* [1];
-        // Initialize net logger on the blocking pool and start observing event
-        // with in on IO thread.
+        base::ScopedFILE* file = new base::ScopedFILE();
+        // Initialize a FILE on the blocking pool and start observing event
+        // on IO thread.
         GetSequencedTaskRunner()->PostTaskAndReply(
             FROM_HERE,
-            base::Bind(&LogPrivateAPI::InitializeNetLogger,
+            base::Bind(&LogPrivateAPI::CreateFileForNetLogger,
                        base::Unretained(this),
                        caller_extension_id,
-                       net_logger_ptr),
+                       file),
             base::Bind(&LogPrivateAPI::StartObservingNetEvents,
                        base::Unretained(this),
                        io_thread,
-                       base::Owned(net_logger_ptr)));
+                       base::Owned(file)));
         break;
       }
       case api::log_private::EVENT_SINK_NONE: {
         NOTREACHED();
         break;
       }
     }
   }
 }
 
@@ skipping 18 matching lines @@
 
 void LogPrivateAPI::StopNetInternalLogging() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (net_log() && logging_net_internals_) {
     logging_net_internals_ = false;
     switch (event_sink_) {
       case api::log_private::EVENT_SINK_CAPTURE:
         net_log()->RemoveThreadSafeObserver(this);
         break;
       case api::log_private::EVENT_SINK_FILE:
-        net_log_logger_->StopObserving();
+        net_log_logger_->StopObserving(nullptr);
         net_log_logger_.reset();
         break;
       case api::log_private::EVENT_SINK_NONE:
         NOTREACHED();
         break;
     }
   }
 }
 
 void LogPrivateAPI::Initialize() {
@@ skipping 166 matching lines @@
   entry->SetBoolean("isDirectory", false);
   base::ListValue* entry_list = new base::ListValue();
   entry_list->Append(entry);
   response->Set("entries", entry_list);
   response->SetBoolean("multiple", false);
   SetResult(response.release());
   SendResponse(succeeded);
 }
 
 }  // namespace extensions