Fix the timestamp generation for webrtc native log.

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/common/media/webrtc_logging_messages.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "net/base/net_util.h"
 
 namespace net {
 class URLRequestContextGetter;
 }  // namespace net
 
 class PartialCircularBuffer;
 class Profile;
 class RenderProcessHost;
@@ skipping 77 matching lines @@
 
   virtual ~WebRtcLoggingHandlerHost();
 
   // BrowserMessageFilter implementation.
   virtual void OnChannelClosing() OVERRIDE;
   virtual void OnDestruct() const OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message,
                                  bool* message_was_ok) OVERRIDE;
 
   // Handles log message requests from renderer process.
-  void OnAddLogMessage(const std::string& message);
+  void OnAddLogMessages(const std::vector<WebRtcLoggingMessage>& messages);
   void OnLoggingStoppedInRenderer();
 
   // Handles log message requests from browser process.
-  void AddLogMessageFromBrowser(const std::string& message);
+  void AddLogMessageFromBrowser(const base::Time& timestamp,

[dcheng, 2014/04/02 01:20:00]

Minor nit: it's preferred to pass base::Time by value since it's just a 64-bit
integer that fits into a register.

+                                const std::string& message);
 
   void StartLoggingIfAllowed();
   void DoStartLogging();
   void LogInitialInfoOnFileThread();
   void LogInitialInfoOnIOThread(const net::NetworkInterfaceList& network_list);
   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 TriggerUploadLog(const base::FilePath& log_directory);
 
   void FireGenericDoneCallback(GenericDoneCallback* callback,
                                bool success,
                                const std::string& error_message);
 
+  std::string FormatMessageWithTimestamp(const base::Time& timestamp,
+                                         const std::string& message);
+
   scoped_ptr<unsigned char[]> log_buffer_;
   scoped_ptr<PartialCircularBuffer> circular_buffer_;
 
   // The profile associated with our renderer process.
   Profile* 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_;
@@ skipping 10 matching lines @@
   LoggingState logging_state_;
 
   // Only accessed on the IO thread.
   bool upload_log_on_render_close_;
 
   // This is the handle to be passed to the render process. It's stored so that
   // it doesn't have to be passed on when posting messages between threads.
   // It's only accessed on the IO thread.
   base::SharedMemoryHandle foreign_memory_handle_;
 
+  // The system time in ms when logging is started. Reset when logging_state_
+  // changes to STOPPED.
+  base::Time logging_started_time_;
+
   DISALLOW_COPY_AND_ASSIGN(WebRtcLoggingHandlerHost);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_