Replace MockFilterCallback with MockCallback and simplify unit tests.

webkit/glue/media/simple_data_source_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/callback.h"
 #include "media/base/filters.h"
+#include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLResponse.h"
 #include "webkit/glue/media/simple_data_source.h"
 #include "webkit/mocks/mock_webframe.h"
@@ skipping 35 matching lines @@
   SimpleDataSourceTest() {
     for (int i = 0; i < kDataSize; ++i) {
       data_[i] = i;
     }
   }
 
   virtual ~SimpleDataSourceTest() {
     ignore_result(frame_.release());
   }
 
-  void InitializeDataSource(const char* url) {
+  void InitializeDataSource(const char* url,
+                            media::MockCallback* callback) {
     gurl_ = GURL(url);
 
     frame_.reset(new NiceMock<MockWebFrame>());
     url_loader_ = new NiceMock<MockWebURLLoader>();
 
     data_source_ = new SimpleDataSource(MessageLoop::current(),
                                         frame_.get());
 
     // There is no need to provide a message loop to data source.
     data_source_->set_host(&host_);
     data_source_->SetURLLoaderForTest(url_loader_);
 
-    InSequence s;
-
-    data_source_->Initialize(url, callback_.NewCallback());
+    data_source_->Initialize(url, callback);
     MessageLoop::current()->RunAllPending();
   }
 
   void RequestSucceeded(bool is_loaded) {
     WebURLResponse response(gurl_);
     response.setExpectedContentLength(kDataSize);
 
     data_source_->didReceiveResponse(NULL, response);
     int64 size;
     EXPECT_TRUE(data_source_->GetSize(&size));
     EXPECT_EQ(kDataSize, size);
 
     for (int i = 0; i < kDataSize; ++i) {
       data_source_->didReceiveData(NULL, data_ + i, 1);
     }
 
     EXPECT_CALL(host_, SetLoaded(is_loaded));
 
     InSequence s;
     EXPECT_CALL(host_, SetTotalBytes(kDataSize));
     EXPECT_CALL(host_, SetBufferedBytes(kDataSize));
-    EXPECT_CALL(callback_, OnFilterCallback());
-    EXPECT_CALL(callback_, OnCallbackDestroyed());
 
     data_source_->didFinishLoading(NULL, 0);
 
     // Let the tasks to be executed.
     MessageLoop::current()->RunAllPending();
   }
 
   void RequestFailed() {
     InSequence s;
     EXPECT_CALL(host_, SetError(media::PIPELINE_ERROR_NETWORK));
-    EXPECT_CALL(callback_, OnFilterCallback());
-    EXPECT_CALL(callback_, OnCallbackDestroyed());
 
     WebURLError error;
     error.reason = net::ERR_FAILED;
     data_source_->didFail(NULL, error);
 
     // Let the tasks to be executed.
     MessageLoop::current()->RunAllPending();
   }
 
   void DestroyDataSource() {
-    StrictMock<media::MockFilterCallback> callback;
-    EXPECT_CALL(callback, OnFilterCallback());
-    EXPECT_CALL(callback, OnCallbackDestroyed());
-
-    data_source_->Stop(callback.NewCallback());
+    data_source_->Stop(media::NewExpectedCallback());
     MessageLoop::current()->RunAllPending();
 
     data_source_ = NULL;
   }
 
   void AsyncRead() {
     for (int i = 0; i < kDataSize; ++i) {
       uint8 buffer[1];
 
       EXPECT_CALL(*this, ReadCallback(1));
       data_source_->Read(
           i, 1, buffer,
           NewCallback(this, &SimpleDataSourceTest::ReadCallback));
       EXPECT_EQ(static_cast<uint8>(data_[i]), buffer[0]);
     }
   }
 
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
  protected:
   GURL gurl_;
   scoped_ptr<MessageLoop> message_loop_;
   NiceMock<MockWebURLLoader>* url_loader_;
   scoped_refptr<SimpleDataSource> data_source_;
   StrictMock<media::MockFilterHost> host_;
-  StrictMock<media::MockFilterCallback> callback_;
   scoped_ptr<NiceMock<MockWebFrame> > frame_;
 
   char data_[kDataSize];
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDataSourceTest);
 };
 
 TEST_F(SimpleDataSourceTest, InitializeHTTP) {
-  InitializeDataSource(kHttpUrl);
+  InitializeDataSource(kHttpUrl, media::NewExpectedCallback());
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeHTTPS) {
-  InitializeDataSource(kHttpsUrl);
+  InitializeDataSource(kHttpsUrl, media::NewExpectedCallback());
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeFile) {
-  InitializeDataSource(kFileUrl);
+  InitializeDataSource(kFileUrl, media::NewExpectedCallback());
   RequestSucceeded(true);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeData) {
   frame_.reset(new NiceMock<MockWebFrame>());
   url_loader_ = new NiceMock<MockWebURLLoader>();
 
   data_source_ = new SimpleDataSource(MessageLoop::current(),
                                       frame_.get());
   EXPECT_TRUE(data_source_->IsUrlSupported(kDataUrl));
 
   // There is no need to provide a message loop to data source.
   data_source_->set_host(&host_);
   data_source_->SetURLLoaderForTest(url_loader_);
 
   EXPECT_CALL(host_, SetLoaded(true));
   EXPECT_CALL(host_, SetTotalBytes(sizeof(kDataUrlDecoded)));
   EXPECT_CALL(host_, SetBufferedBytes(sizeof(kDataUrlDecoded)));
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
 
-  data_source_->Initialize(kDataUrl, callback_.NewCallback());
+  data_source_->Initialize(kDataUrl, media::NewExpectedCallback());
   MessageLoop::current()->RunAllPending();
 
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, RequestFailed) {
-  InitializeDataSource(kHttpUrl);
+  InitializeDataSource(kHttpUrl, media::NewExpectedCallback());
   RequestFailed();
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, StopWhenDownloading) {
-  InitializeDataSource(kHttpUrl);
+  // The callback should be deleted, but not executed.
+  // TODO(scherkus): should this really be the behaviour?  Seems strange...
+  StrictMock<media::MockCallback>* callback =
+      new StrictMock<media::MockCallback>();
+  EXPECT_CALL(*callback, Destructor());
+
+  InitializeDataSource(kHttpUrl, callback);
 
   EXPECT_CALL(*url_loader_, cancel());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, AsyncRead) {
-  InitializeDataSource(kFileUrl);
+  InitializeDataSource(kFileUrl, media::NewExpectedCallback());
   RequestSucceeded(true);
   AsyncRead();
   DestroyDataSource();
 }
 
 }  // namespace webkit_glue