Split a portion of BufferedResourceLoader into a separate class ActiveLoader.

webkit/media/buffered_data_source_unittest.cc

 // 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.
 
 #include "base/bind.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 #include "webkit/media/test_response_generator.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::Invoke;
-using ::testing::Mock;
 using ::testing::StrictMock;
 using ::testing::NiceMock;
 
 using WebKit::WebFrame;
 using WebKit::WebURLLoader;
 using WebKit::WebURLResponse;
 using WebKit::WebView;
 
 using webkit_glue::MockWebFrameClient;
 using webkit_glue::MockWebURLLoader;
@@ skipping 18 matching lines @@
         BufferedDataSource::CreateResourceLoader(first_byte_position,
                                                  last_byte_position);
 
     // Keep track of active loading state via loadAsynchronously() and cancel().
     NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
     ON_CALL(*url_loader, loadAsynchronously(_, _))
         .WillByDefault(Assign(&loading_, true));
     ON_CALL(*url_loader, cancel())
         .WillByDefault(Assign(&loading_, false));
 
-    // TODO(scherkus): this is a real leak detected by http://crbug.com/100914
-    // but the fix will have to wait for a more invasive follow up patch.
-    //
-    // If you're curious what the fix is, we no longer need the reference
-    // counting added to BufferedResourceLoader in r23274 since we started
-    // using WebURLLoader in r69429.
-    Mock::AllowLeak(url_loader);
-
     loader->SetURLLoaderForTest(url_loader);
     return loader;
   }
 
   bool loading() { return loading_; }
   void set_loading(bool loading) { loading_ = loading; }
 
  private:
   // Whether the resource load has starting loading but yet to been cancelled.
   bool loading_;
@@ skipping 79 matching lines @@
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
   void ReadAt(int64 position) {
     data_source_->Read(position, kDataSize, buffer_,
                        base::Bind(&BufferedDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
     message_loop_->RunAllPending();
   }
 
   // Accessors for private variables on |data_source_|.
-  BufferedResourceLoader* loader() { return data_source_->loader_.get(); }
-  WebURLLoader* url_loader() { return loader()->url_loader_.get(); }
+  BufferedResourceLoader* loader() {
+    return data_source_->loader_.get();
+  }
+  WebURLLoader* url_loader() {
+    return loader()->active_loader_->loader_.get();
+  }
 
   media::Preload preload() { return data_source_->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_; }
 
@@ skipping 224 matching lines @@
   // Read so far ahead to cause the loader to get recreated.
   BufferedResourceLoader* old_loader = loader();
   ExpectCreateResourceLoader();
   ReadAt(kFarReadPosition);
   Respond(response_generator_.Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same bitrate.
   EXPECT_NE(old_loader, loader());
   EXPECT_EQ(1234, loader_bitrate());
 
+  // During teardown we'll also report our final network status.
+  EXPECT_CALL(host_, SetBufferedBytes(4000000));
+
   EXPECT_TRUE(data_source_->loading());
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, SetPlaybackRate) {
   InitializeWith206Response();
 
   data_source_->SetPlaybackRate(2.0f);
   message_loop_->RunAllPending();
   EXPECT_EQ(2.0f, data_source_playback_rate());
   EXPECT_EQ(2.0f, loader_playback_rate());
 
   // Read so far ahead to cause the loader to get recreated.
   BufferedResourceLoader* old_loader = loader();
   ExpectCreateResourceLoader();
   ReadAt(kFarReadPosition);
   Respond(response_generator_.Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same playback rate.
   EXPECT_NE(old_loader, loader());
 
+  // During teardown we'll also report our final network status.
+  EXPECT_CALL(host_, SetBufferedBytes(4000000));
+
   EXPECT_TRUE(data_source_->loading());
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Read) {
   InitializeWith206Response();
 
   ReadAt(0);
 
   // When the read completes we'll update our network status.
   EXPECT_CALL(host_, SetBufferedBytes(kDataSize));
   EXPECT_CALL(host_, SetNetworkActivity(true));
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   FinishRead();
 
   // During teardown we'll also report our final network status.
   EXPECT_CALL(host_, SetBufferedBytes(kDataSize));
   EXPECT_CALL(host_, SetNetworkActivity(false));
 
   EXPECT_TRUE(data_source_->loading());
   Stop();
 }
 
 }  // namespace webkit_media