Revert of Unit test for WebMediaPlayerMS

content/renderer/media/webmediaplayer_ms_compositor.h

 // Copyright 2015 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 CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_COMPOSITOR_H
 #define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_COMPOSITOR_H
 
 #include <map>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "cc/layers/video_frame_provider.h"
-#include "content/common/content_export.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace blink {
 class WebURL;
 }
 
 namespace gfx {
@@ skipping 10 matching lines @@
 
 // This class is designed to handle the work load on compositor thread for
 // WebMediaPlayerMS. It will be instantiated on the main thread, but destroyed
 // on the compositor thread.
 //
 // WebMediaPlayerMSCompositor utilizes VideoRendererAlgorithm to store the
 // incoming frames and select the best frame for rendering to maximize the
 // smoothness, if REFERENCE_TIMEs are populated for incoming VideoFrames.
 // Otherwise, WebMediaPlayerMSCompositor will simply store the most recent
 // frame, and submit it whenever asked by the compositor.
-class CONTENT_EXPORT WebMediaPlayerMSCompositor
-    : public NON_EXPORTED_BASE(cc::VideoFrameProvider) {
+class WebMediaPlayerMSCompositor : public cc::VideoFrameProvider {
  public:
-  // This |url| represents the media stream we are rendering. |url| is used to
-  // find out what web stream this WebMediaPlayerMSCompositor is playing, and
-  // together with flag "--disable-rtc-smoothness-algorithm" determine whether
-  // we enable algorithm or not.
+  // This |url| represents the media stream we are rendering.
   WebMediaPlayerMSCompositor(
       const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
       const blink::WebURL& url,
       const base::WeakPtr<WebMediaPlayerMS>& player);
-
   ~WebMediaPlayerMSCompositor() override;
 
   void EnqueueFrame(const scoped_refptr<media::VideoFrame>& frame);
 
   // Statistical data
   gfx::Size GetCurrentSize();
   base::TimeDelta GetCurrentTime();
   size_t total_frame_count() const;
   size_t dropped_frame_count() const;
 
   // VideoFrameProvider implementation.
   void SetVideoFrameProviderClient(
       cc::VideoFrameProvider::Client* client) override;
   bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                           base::TimeTicks deadline_max) override;
   bool HasCurrentFrame() override;
   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override;
 
   void StartRendering();
   void StopRendering();
   void ReplaceCurrentFrameWithACopy();
 
  private:
-  friend class WebMediaPlayerMSTest;
-
   bool MapTimestampsToRenderTimeTicks(
       const std::vector<base::TimeDelta>& timestamps,
       std::vector<base::TimeTicks>* wall_clock_times);
 
   void SetCurrentFrame(const scoped_refptr<media::VideoFrame>& frame);
 
   // For algorithm enabled case only: given the render interval, update
   // current_frame_ and dropped_frame_count_.
   void Render(base::TimeTicks deadline_min, base::TimeTicks deadline_max);
 
   void StartRenderingInternal();
   void StopRenderingInternal();
 
-  void SetAlgorithmEnabledForTesting(bool algorithm_enabled);
-
   // Used for DCHECKs to ensure method calls executed in the correct thread.
   base::ThreadChecker thread_checker_;
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   base::MessageLoop* main_message_loop_;
 
   base::WeakPtr<WebMediaPlayerMS> player_;
 
   size_t serial_;
 
@@ skipping 32 matching lines @@
 
   std::map<base::TimeDelta, base::TimeTicks> timestamps_to_clock_times_;
 
   // |current_frame_lock_| protects |current_frame_used_by_compositor_|,
   // |current_frame_|, and |rendering_frame_buffer_|.
   base::Lock current_frame_lock_;
 };
 }
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_COMPOSITOR_H