Convert WebRtcLoggingHandlerHost to use the blocking thread pool.

chrome/browser/media/webrtc_logging_handler_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
 #define CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
 
 #include "base/basictypes.h"
 #include "base/memory/shared_memory.h"
 #include "chrome/browser/media/rtp_dump_type.h"
 #include "chrome/browser/media/webrtc_rtp_dump_handler.h"
 #include "chrome/common/media/webrtc_logging_message_data.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/render_process_host.h"
 #include "net/base/net_util.h"
 
-namespace net {
-class URLRequestContextGetter;
-}  // namespace net
-
 class PartialCircularBuffer;
 class Profile;
 
 typedef std::map<std::string, std::string> MetaDataMap;
 
 // WebRtcLoggingHandlerHost handles operations regarding the WebRTC logging:
 // - Opens a shared memory buffer that the handler in the render process
 //   writes to.
 // - Writes basic machine info to the log.
 // - Informs the handler in the render process when to stop logging.
@@ skipping 98 matching lines @@
 
   // Handles log message requests from renderer process.
   void OnAddLogMessages(const std::vector<WebRtcLoggingMessageData>& messages);
   void OnLoggingStoppedInRenderer();
 
   // Handles log message requests from browser process.
   void AddLogMessageFromBrowser(const WebRtcLoggingMessageData& message);
 
   void StartLoggingIfAllowed();
   void DoStartLogging();
-  void LogInitialInfoOnFileThread();
-  void LogInitialInfoOnIOThread(const net::NetworkInterfaceList& network_list);
+  void LogInitialInfoOnBlockingPool();
+  void LogInitialInfoOnIOThread(const net::NetworkInterfaceList& network_list,
+                                const std::string& linux_distro);
   void NotifyLoggingStarted();
 
   // Writes a formatted log |message| to the |circular_buffer_|.
   void LogToCircularBuffer(const std::string& message);
 
   // Gets the log directory path for |profile_| and ensure it exists. Must be
   // called on the FILE thread.
   base::FilePath GetLogDirectoryAndEnsureExists();
 
   void TriggerUpload(const base::FilePath& log_directory);
@@ skipping 18 matching lines @@
   // Adds the packet to the dump on IO thread.
   void DumpRtpPacketOnIOThread(scoped_ptr<uint8[]> packet_header,
                                size_t header_length,
                                size_t packet_length,
                                bool incoming);
 
   scoped_ptr<unsigned char[]> log_buffer_;
   scoped_ptr<PartialCircularBuffer> circular_buffer_;
 
   // The profile associated with our renderer process.
-  Profile* profile_;
+  const Profile* const profile_;
 
   // These are only accessed on the IO thread, except when in STARTING state. In
   // this state we are protected since entering any function that alters the
   // state is not allowed.
   MetaDataMap meta_data_;
 
   // These are only accessed on the IO thread.
   GenericDoneCallback start_callback_;
   GenericDoneCallback stop_callback_;
   UploadDoneCallback upload_callback_;
@@ skipping 19 matching lines @@
   // The RTP dump handler responsible for creating the RTP header dump files.
   scoped_ptr<WebRtcRtpDumpHandler> rtp_dump_handler_;
 
   // The callback to call when StopRtpDump is called.
   content::RenderProcessHost::WebRtcStopRtpDumpCallback stop_rtp_dump_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcLoggingHandlerHost);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_