Log PipelineImpl events to MediaLog.

media/base/pipeline_impl.h

 // Copyright (c) 2011 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.
 
 // Implementation of Pipeline & PipelineStatusNotification (an async-to-sync
 // callback adapter).
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "media/base/clock.h"
 #include "media/base/composite_filter.h"
 #include "media/base/filter_host.h"
 #include "media/base/pipeline.h"
 
 namespace media {
 
+class MediaLog;
+
 // Adapter for using asynchronous Pipeline methods in code that wants to run
 // synchronously.  To use, construct an instance of this class and pass the
 // |Callback()| to the Pipeline method requiring a callback.  Then Wait() for
 // the callback to get fired and call status() to see what the callback's
 // argument was.  This object is for one-time use; call |Callback()| exactly
 // once.
 class PipelineStatusNotification {
  public:
   PipelineStatusNotification();
   ~PipelineStatusNotification();
@@ skipping 46 matching lines @@
 // completed, we are implicitly in a "Paused" state.  At that point we simulate
 // a Seek() to the beginning of the media to give filters a chance to preroll.
 // From then on the normal Seek() transitions are carried out and we start
 // playing the media.
 //
 // If any error ever happens, this object will transition to the "Error" state
 // from any state. If Stop() is ever called, this object will transition to
 // "Stopped" state.
 class PipelineImpl : public Pipeline, public FilterHost {
  public:
-  explicit PipelineImpl(MessageLoop* message_loop);
+  explicit PipelineImpl(MessageLoop* message_loop, MediaLog* media_log);
 
   // Pipeline implementation.
   virtual void Init(PipelineStatusCallback* ended_callback,
                     PipelineStatusCallback* error_callback,
                     PipelineStatusCallback* network_callback);
   virtual bool Start(FilterCollection* filter_collection,
                      const std::string& uri,
                      PipelineStatusCallback* start_callback);
   virtual void Stop(PipelineStatusCallback* stop_callback);
   virtual void Seek(base::TimeDelta time,
@@ skipping 14 matching lines @@
   virtual int64 GetBufferedBytes() const;
   virtual int64 GetTotalBytes() const;
   virtual void GetVideoSize(size_t* width_out, size_t* height_out) const;
   virtual bool IsStreaming() const;
   virtual bool IsLoaded() const;
   virtual PipelineStatistics GetStatistics() const;
 
   void SetClockForTesting(Clock* clock);
 
  private:
+  friend class MediaLog;
+
   // Pipeline states, as described above.
   enum State {
     kCreated,
     kInitDemuxer,
     kInitAudioDecoder,
     kInitAudioRenderer,
     kInitVideoDecoder,
     kInitVideoRenderer,
     kPausing,
     kSeeking,
     kFlushing,
     kStarting,
     kStarted,
     kEnded,
     kStopping,
     kStopped,
     kError,
   };
 
   virtual ~PipelineImpl();
 
   // Reset the state of the pipeline object to the initial state.  This method
   // is used by the constructor, and the Stop() method.
   void ResetState();
 
   // Updates |state_|. All state transitions should use this call.
-  void set_state(State next_state);
+  void SetState(State next_state);
 
   // Simple method used to make sure the pipeline is running normally.
   bool IsPipelineOk();
 
   // Helper method to tell whether we are stopped or in error.
   bool IsPipelineStopped();
 
   // Helper method to tell whether we are in transition to stop state.
   bool IsPipelineTearingDown();
 
@@ skipping 139 matching lines @@
   // This will remove the race condition during stop between filters.
   void TearDownPipeline();
 
   // Compute the current time. Assumes that the lock has been acquired by the
   // caller.
   base::TimeDelta GetCurrentTime_Locked() const;
 
   // Message loop used to execute pipeline tasks.
   MessageLoop* message_loop_;
 
+  // MediaLog to which to log events.
+  scoped_refptr<MediaLog> media_log_;
+
   // Lock used to serialize access for the following data members.
   mutable base::Lock lock_;
 
   // Whether or not the pipeline is running.
   bool running_;
 
   // Whether or not the pipeline is in transition for a seek operation.
   bool seek_pending_;
 
   // Whether or not the pipeline is pending a stop operation.
@@ skipping 128 matching lines @@
   PipelineStatistics statistics_;
 
   FRIEND_TEST_ALL_PREFIXES(PipelineImplTest, GetBufferedTime);
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_