Replace Pipeline::SetNetworkActivity() with BufferedDataSource -> WebMediaPlayerImpl callback.

webkit/media/buffered_data_source_unittest.cc

 // Copyright (c) 2012 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.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_data_source_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 19 matching lines @@
 using webkit_glue::MockWebFrameClient;
 using webkit_glue::MockWebURLLoader;
 
 namespace webkit_media {
 
 // Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader.
 // Also keeps track of whether said MockWebURLLoader is actively loading.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   MockBufferedDataSource(MessageLoop* message_loop, WebFrame* frame)
-      : BufferedDataSource(message_loop, frame, new media::MediaLog()),
+      : BufferedDataSource(message_loop, frame, new media::MediaLog(),
+                           base::Bind(&MockBufferedDataSource::set_downloading,
+                                      base::Unretained(this))),
+        downloading_(false),
         loading_(false) {
   }
 
   MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64));
   BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position,
                                                    int64 last_byte_position) {
     CHECK(!loading_) << "Previous resource load wasn't cancelled";
 
     BufferedResourceLoader* loader =
         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));
 
     // |test_loader_| will be used when Start() is called.
     loader->test_loader_ = scoped_ptr<WebURLLoader>(url_loader);
     return loader;
   }
 
   bool loading() { return loading_; }
   void set_loading(bool loading) { loading_ = loading; }
+  bool downloading() { return downloading_; }
+  void set_downloading(bool downloading) { downloading_ = downloading; }
 
  private:
   virtual ~MockBufferedDataSource() {}
 
+  // Whether the resource is downloading or deferred.
+  bool downloading_;
+
   // Whether the resource load has starting loading but yet to been cancelled.
   bool loading_;
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 static const int64 kFileSize = 5000000;
 static const int64 kFarReadPosition = 4000000;
 static const int kDataSize = 1024;
 
@@ skipping 85 matching lines @@
 
   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_; }
 
-
   scoped_refptr<MockBufferedDataSource> data_source_;
 
   TestResponseGenerator response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
 
   StrictMock<media::MockDataSourceHost> host_;
   MessageLoop message_loop_;
 
  private:
@@ skipping 238 matching lines @@
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Read) {
   InitializeWith206Response();
 
   ReadAt(0);
 
   // When the read completes we'll update our network status.
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
-  EXPECT_CALL(host_, SetNetworkActivity(true));
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   FinishRead();
+  EXPECT_TRUE(data_source_->downloading());
 
   // During teardown we'll also report our final network status.
-  EXPECT_CALL(host_, SetNetworkActivity(false));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
 
-  EXPECT_TRUE(data_source_->loading());
+  EXPECT_TRUE(data_source_->downloading());
   Stop();
+  EXPECT_FALSE(data_source_->downloading());
 }
 
 }  // namespace webkit_media