Report stalled event correctly for <video>

webkit/glue/media/buffered_data_source_unittest.cc

 // Copyright (c) 2009 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 <algorithm>
 
 #include "base/string_util.h"
 #include "media/base/filters.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 64 matching lines @@
                                          first_position_, last_position_);
     EXPECT_EQ(gurl_.spec(), loader_->GetURLForDebugging());
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(bridge_factory_,
                 CreateBridge(gurl_, _, first_position_, last_position_))
         .WillOnce(Return(bridge_.get()));
     EXPECT_CALL(*bridge_, Start(loader_.get()));
-    loader_->Start(NewCallback(this,
-                               &BufferedResourceLoaderTest::StartCallback));
+    loader_->Start(
+        NewCallback(this, &BufferedResourceLoaderTest::StartCallback),
+        NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback));
   }
 
   void FullResponse(int64 instance_size) {
     EXPECT_CALL(*this, StartCallback(net::OK));
     ResourceLoaderBridge::ResponseInfo info;
     std::string header = StringPrintf("HTTP/1.1 200 OK\n"
                                       "Content-Length: %lld", instance_size);
     replace(header.begin(), header.end(), '\n', '\0');
     info.headers = new net::HttpResponseHeaders(header);
     info.content_length = instance_size;
@@ skipping 30 matching lines @@
         .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
     loader_->Stop();
   }
 
   void ReleaseBridge() {
     bridge_.release();
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
+    EXPECT_CALL(*this, NetworkCallback());
     loader_->OnReceivedData(reinterpret_cast<char*>(data_ + position), size);
   }
 
   // Helper method to read from |loader_|.
   void ReadLoader(int64 position, int size, uint8* buffer) {
     loader_->Read(position, size, buffer,
                   NewCallback(this, &BufferedResourceLoaderTest::ReadCallback));
   }
 
   // Verifis that data in buffer[0...size] is equal to data_[pos...pos+size].
   void VerifyBuffer(uint8* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
   MOCK_METHOD1(StartCallback, void(int error));
   MOCK_METHOD1(ReadCallback, void(int error));
+  MOCK_METHOD0(NetworkCallback, void());
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
 
   scoped_refptr<BufferedResourceLoader> loader_;
   StrictMock<MockMediaResourceLoaderBridgeFactory> bridge_factory_;
   scoped_ptr<StrictMock<MockResourceLoaderBridge> > bridge_;
 
@@ skipping 112 matching lines @@
   // Read backward within buffer.
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(10, 10, buffer);
   VerifyBuffer(buffer, 10, 10);
 
   // Read backward outside buffer.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(9, 10, buffer);
 
   // Response has completed.
+  EXPECT_CALL(*this, NetworkCallback());
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::SUCCESS);
   loader_->OnCompletedRequest(status, "");
 
   // Try to read 10 from position 25 will just return with 5 bytes.
   EXPECT_CALL(*this, ReadCallback(5));
   ReadLoader(25, 10, buffer);
   VerifyBuffer(buffer, 25, 5);
@@ skipping 25 matching lines @@
 
   // Writing to loader will fulfill the read request.
   EXPECT_CALL(*this, ReadCallback(10));
   WriteLoader(10, 20);
   VerifyBuffer(buffer, 10, 10);
 
   // The following call cannot be fulfilled now.
   ReadLoader(25, 10, buffer);
 
   EXPECT_CALL(*this, ReadCallback(5));
+  EXPECT_CALL(*this, NetworkCallback());
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::SUCCESS);
   loader_->OnCompletedRequest(status, "");
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   ReadLoader(10, 10, buffer);
   EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
+  EXPECT_CALL(*this, NetworkCallback());
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::FAILED);
   loader_->OnCompletedRequest(status, "");
 }
 
 // TODO(hclam): add unit test for defer loading.
 
 class MockBufferedResourceLoader : public BufferedResourceLoader {
  public:
   MockBufferedResourceLoader() : BufferedResourceLoader() {
   }
 
-  MOCK_METHOD1(Start, void(net::CompletionCallback* read_callback));
+  MOCK_METHOD2(Start, void(net::CompletionCallback* read_callback,
+                           NetworkEventCallback* network_callback));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD4(Read, void(int64 position, int read_size, uint8* buffer,
                           net::CompletionCallback* callback));
   MOCK_METHOD0(content_length, int64());
   MOCK_METHOD0(instance_size, int64());
   MOCK_METHOD0(partial_response, bool());
+  MOCK_METHOD0(network_activity, bool());
+  MOCK_METHOD0(GetBufferedFirstBytePosition, int64());
+  MOCK_METHOD0(GetBufferedLastBytePosition, int64());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedResourceLoader);
 };
 
 // A mock BufferedDataSource to inject mock BufferedResourceLoader through
-// CreateLoader() method.
+// CreateResourceLoader() method.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   // Static methods for creating this class.
   static media::FilterFactory* CreateFactory(
       MessageLoop* message_loop,
       MediaResourceLoaderBridgeFactory* bridge_factory) {
     return new media::FilterFactoryImpl2<
         MockBufferedDataSource,
         MessageLoop*,
         MediaResourceLoaderBridgeFactory*>(message_loop,
                                            bridge_factory);
   }
 
   virtual base::TimeDelta GetTimeoutMilliseconds() {
     // It is 100 ms because we don't want the test to run too long.
     return base::TimeDelta::FromMilliseconds(100);
   }
 
-  MOCK_METHOD2(CreateLoader, BufferedResourceLoader*(int64 first_position,
-                                                     int64 last_position));
+  MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(
+      int64 first_position, int64 last_position));
 
  protected:
   MockBufferedDataSource(
-      MessageLoop* message_loop,
-      MediaResourceLoaderBridgeFactory* factory)
+      MessageLoop* message_loop, MediaResourceLoaderBridgeFactory* factory)
       : BufferedDataSource(message_loop, factory) {
   }
 
  private:
   friend class media::FilterFactoryImpl2<
       MockBufferedDataSource,
       MessageLoop*,
       MediaResourceLoaderBridgeFactory*>;
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
@@ skipping 42 matching lines @@
 
     // There is no need to provide a message loop to data source.
     data_source_->set_host(&host_);
 
     // Creates the mock loader to be injected.
     loader_ = new StrictMock<MockBufferedResourceLoader>();
 
     bool loaded = networkState == LOADED;
     {
       InSequence s;
-      EXPECT_CALL(*data_source_, CreateLoader(_, _))
+      EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
           .WillOnce(Return(loader_.get()));
 
       // The initial response loader will be started.
-      EXPECT_CALL(*loader_, Start(NotNull()))
+      EXPECT_CALL(*loader_, Start(NotNull(), NotNull()))
           .WillOnce(
               DoAll(Assign(&error_, error),
                     Invoke(this,
                            &BufferedDataSourceTest::InvokeStartCallback)));
     }
 
     StrictMock<media::MockFilterCallback> callback;
+    EXPECT_CALL(*loader_, instance_size())
+        .WillRepeatedly(Return(instance_size));
+    EXPECT_CALL(*loader_, partial_response())
+        .WillRepeatedly(Return(partial_response));
     if (error == net::OK) {
       // Expected loaded or not.
       EXPECT_CALL(host_, SetLoaded(loaded));
-      EXPECT_CALL(*loader_, instance_size())
-          .WillRepeatedly(Return(instance_size));
-      EXPECT_CALL(*loader_, partial_response())
-          .WillRepeatedly(Return(partial_response));
 
       // TODO(hclam): The condition for streaming needs to be adjusted.
       if (instance_size != -1 && (loaded || partial_response)) {
         EXPECT_CALL(host_, SetTotalBytes(instance_size));
-        EXPECT_CALL(host_, SetBufferedBytes(instance_size));
+        if (loaded)
+          EXPECT_CALL(host_, SetBufferedBytes(instance_size));
+        else
+          EXPECT_CALL(host_, SetBufferedBytes(0));
       } else {
         EXPECT_CALL(host_, SetStreaming(true));
       }
 
       EXPECT_CALL(callback, OnFilterCallback());
       EXPECT_CALL(callback, OnCallbackDestroyed());
     } else {
       EXPECT_CALL(host_, SetError(media::PIPELINE_ERROR_NETWORK));
       EXPECT_CALL(*loader_, Stop());
       EXPECT_CALL(callback, OnFilterCallback());
@@ skipping 23 matching lines @@
     }
 
     data_source_->Stop();
     message_loop_->RunAllPending();
   }
 
   void ReleaseBridgeFactory() {
     bridge_factory_.release();
   }
 
-  void InvokeStartCallback(net::CompletionCallback* callback) {
+  void InvokeStartCallback(
+      net::CompletionCallback* callback,
+      BufferedResourceLoader::NetworkEventCallback* network_callback) {
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
+    // TODO(hclam): Save this callback.
+    delete network_callback;
   }
 
   void InvokeReadCallback(int64 position, int size, uint8* buffer,
                           net::CompletionCallback* callback) {
     if (error_ > 0)
       memcpy(buffer, data_ + static_cast<int>(position), error_);
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
   }
 
@@ skipping 29 matching lines @@
       EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
           .WillOnce(DoAll(Assign(&error_, net::ERR_CACHE_MISS),
                           Invoke(this,
                                  &BufferedDataSourceTest::InvokeReadCallback)));
       EXPECT_CALL(*loader_, Stop());
     }
 
     // 2. Then the current loader will be stop and destroyed.
     StrictMock<MockBufferedResourceLoader> *new_loader =
         new StrictMock<MockBufferedResourceLoader>();
-    EXPECT_CALL(*data_source_, CreateLoader(position, -1))
+    EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started.
-    EXPECT_CALL(*new_loader, Start(NotNull()))
+    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
     EXPECT_CALL(*new_loader, partial_response())
         .WillRepeatedly(Return(loader_->partial_response()));
 
     // 4. Then again a read request is made to the new loader.
     EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, size),
                         Invoke(this,
@@ skipping 39 matching lines @@
     {
       InSequence s;
       EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
           .WillOnce(DeleteArg<3>());
       EXPECT_CALL(*loader_, Stop());
     }
 
     // 2. Then the current loader will be stop and destroyed.
     StrictMock<MockBufferedResourceLoader> *new_loader =
         new StrictMock<MockBufferedResourceLoader>();
-    EXPECT_CALL(*data_source_, CreateLoader(position, -1))
+    EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started and respond to queries about
     //    whether this is a partial response using the value of the previous
     //    loader.
-    EXPECT_CALL(*new_loader, Start(NotNull()))
+    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
     EXPECT_CALL(*new_loader, partial_response())
         .WillRepeatedly(Return(loader_->partial_response()));
 
     // 4. Then again a read request is made to the new loader.
     EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, size),
                         Invoke(this,
@@ skipping 15 matching lines @@
     EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
 
     loader_ = new_loader;
   }
 
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
   scoped_ptr<StrictMock<MockMediaResourceLoaderBridgeFactory> >
       bridge_factory_;
   scoped_refptr<StrictMock<MockBufferedResourceLoader> > loader_;
-  scoped_refptr<MockBufferedDataSource > data_source_;
+  scoped_refptr<MockBufferedDataSource> data_source_;
   scoped_refptr<media::FilterFactory> factory_;
 
   StrictMock<media::MockFilterHost> host_;
   GURL gurl_;
   scoped_ptr<MessageLoop> message_loop_;
 
   int error_;
   uint8 buffer_[1024];
   uint8 data_[1024];
 
@@ skipping 59 matching lines @@
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, FileHasLoadedState) {
   InitializeDataSource(kFileUrl, net::OK, true, 1024, LOADED);
   ReadDataSourceTimesOut(20, 10);
   StopDataSource();
 }
 
 }  // namespace webkit_glue