Move Preload enum to BufferedDataSource.

content/renderer/media/buffered_data_source_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/common/url_constants.h"
 #include "content/renderer/media/buffered_data_source.h"
 #include "content/renderer/media/test_response_generator.h"
 #include "content/test/mock_webframeclient.h"
@@ skipping 94 matching lines @@
 static const int kDataSize = 1024;
 
 static const char kHttpUrl[] = "http://localhost/foo.webm";
 static const char kFileUrl[] = "file:///tmp/bar.webm";
 
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest()
       : view_(WebView::create(NULL)),
         frame_(WebLocalFrame::create(&client_)),
-        preload_(AUTO) {
+        preload_(BufferedDataSource::AUTO) {
     view_->setMainFrame(frame_);
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
     frame_->close();
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
@@ skipping 92 matching lines @@
   }
 
   // Accessors for private variables on |data_source_|.
   BufferedResourceLoader* loader() {
     return data_source_->loader_.get();
   }
   WebURLLoader* url_loader() {
     return loader()->active_loader_->loader_.get();
   }
 
-  Preload preload() { return data_source_->preload_; }
-  void set_preload(Preload preload) { preload_ = preload; }
+  BufferedDataSource::Preload preload() { return data_source_->preload_; }
+  void set_preload(BufferedDataSource::Preload preload) { preload_ = preload; }
   BufferedResourceLoader::DeferStrategy defer_strategy() {
     return loader()->defer_strategy_;
   }
   int data_source_bitrate() { return data_source_->bitrate_; }
   int data_source_playback_rate() { return data_source_->playback_rate_; }
   int loader_bitrate() { return loader()->bitrate_; }
   int loader_playback_rate() { return loader()->playback_rate_; }
   bool is_local_source() { return data_source_->assume_fully_buffered(); }
   void set_might_be_reused_from_cache_in_future(bool value) {
     loader()->might_be_reused_from_cache_in_future_ = value;
   }
 
   scoped_ptr<MockBufferedDataSource> data_source_;
 
   scoped_ptr<TestResponseGenerator> response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
 
  private:
   // Used for calling BufferedDataSource::Read().
   uint8 buffer_[kDataSize];
 
-  Preload preload_;
+  BufferedDataSource::Preload preload_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, Range_Supported) {
   InitializeWith206Response();
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
@@ skipping 251 matching lines @@
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
     data_source_->Stop();
   }
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(BufferedDataSourceTest, DefaultValues) {
   InitializeWith206Response();
 
   // Ensure we have sane values for default loading scenario.
-  EXPECT_EQ(AUTO, preload());
+  EXPECT_EQ(BufferedDataSource::AUTO, preload());
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   EXPECT_EQ(0, data_source_bitrate());
   EXPECT_EQ(0.0f, data_source_playback_rate());
   EXPECT_EQ(0, loader_bitrate());
   EXPECT_EQ(0.0f, loader_playback_rate());
 
   EXPECT_TRUE(data_source_->loading());
   Stop();
 }
@@ skipping 117 matching lines @@
   EXPECT_FALSE(data_source_->downloading());
   FinishLoading();
   EXPECT_FALSE(data_source_->downloading());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, LocalResource_DeferStrategy) {
   InitializeWithFileResponse();
 
-  EXPECT_EQ(AUTO, preload());
+  EXPECT_EQ(BufferedDataSource::AUTO, preload());
   EXPECT_TRUE(is_local_source());
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
-  set_preload(METADATA);
+  set_preload(BufferedDataSource::METADATA);
   InitializeWithFileResponse();
 
-  EXPECT_EQ(METADATA, preload());
+  EXPECT_EQ(BufferedDataSource::METADATA, preload());
   EXPECT_TRUE(is_local_source());
   EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
   InitializeWith200Response();
 
-  EXPECT_EQ(AUTO, preload());
+  EXPECT_EQ(BufferedDataSource::AUTO, preload());
   EXPECT_FALSE(is_local_source());
   EXPECT_FALSE(loader()->range_supported());
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest,
        ExternalResource_Response200_PreloadMetadata_DeferStrategy) {
-  set_preload(METADATA);
+  set_preload(BufferedDataSource::METADATA);
   InitializeWith200Response();
 
-  EXPECT_EQ(METADATA, preload());
+  EXPECT_EQ(BufferedDataSource::METADATA, preload());
   EXPECT_FALSE(is_local_source());
   EXPECT_FALSE(loader()->range_supported());
   EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
   InitializeWith206Response();
 
-  EXPECT_EQ(AUTO, preload());
+  EXPECT_EQ(BufferedDataSource::AUTO, preload());
   EXPECT_FALSE(is_local_source());
   EXPECT_TRUE(loader()->range_supported());
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
   set_might_be_reused_from_cache_in_future(true);
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
   set_might_be_reused_from_cache_in_future(false);
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest,
        ExternalResource_Response206_PreloadMetadata_DeferStrategy) {
-  set_preload(METADATA);
+  set_preload(BufferedDataSource::METADATA);
   InitializeWith206Response();
 
-  EXPECT_EQ(METADATA, preload());
+  EXPECT_EQ(BufferedDataSource::METADATA, preload());
   EXPECT_FALSE(is_local_source());
   EXPECT_TRUE(loader()->range_supported());
   EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
   set_might_be_reused_from_cache_in_future(true);
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
   set_might_be_reused_from_cache_in_future(false);
   data_source_->MediaIsPaused();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
 }
 
 }  // namespace content