Remove MockWebFrame in favour of MockWebFrameClient and update corresponding tests.

webkit/glue/media/simple_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 "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/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/media/simple_data_source.h"
-#include "webkit/mocks/mock_webframe.h"
+#include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::WithArgs;
 
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
+using WebKit::WebView;
 
 namespace webkit_glue {
 
 static const int kDataSize = 1024;
 static const char kHttpUrl[] = "http://test";
 static const char kHttpsUrl[] = "https://test";
 static const char kFileUrl[] = "file://test";
 static const char kDataUrl[] =
     "data:text/plain;base64,YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoK";
 static const char kDataUrlDecoded[] = "abcdefghijklmnopqrstuvwxyz";
 static const char kInvalidUrl[] = "whatever://test";
 static const char kHttpRedirectToSameDomainUrl1[] = "http://test/ing";
 static const char kHttpRedirectToSameDomainUrl2[] = "http://test/ing2";
 static const char kHttpRedirectToDifferentDomainUrl1[] = "http://test2";
 static const char kHttpRedirectToDifferentDomainUrl2[] = "http://test2/ing";
 
 class SimpleDataSourceTest : public testing::Test {
  public:
-  SimpleDataSourceTest() {
+  SimpleDataSourceTest()
+      : view_(NULL) {
     for (int i = 0; i < kDataSize; ++i) {
       data_[i] = i;
     }
   }
 
   virtual ~SimpleDataSourceTest() {
+    if (view_) {

[acolwell GONE FROM CHROMIUM, 2011/05/13 17:36:37]

nit:braces

[scherkus (not reviewing), 2011/05/13 19:35:20]

Done.

+      view_->close();
+    }
   }
 
   void InitializeDataSource(const char* url,
                             media::MockStatusCallback* callback) {
     gurl_ = GURL(url);
 
-    frame_.reset(new NiceMock<MockWebFrame>());
+    view_ = WebView::create(NULL);
+    view_->initializeMainFrame(&client_);
+
     url_loader_ = new NiceMock<MockWebURLLoader>();
 
     data_source_ = new SimpleDataSource(MessageLoop::current(),
-                                        frame_.get());
+                                        view_->mainFrame());
 
     // There is no need to provide a message loop to data source.
     data_source_->set_host(&host_);
     data_source_->SetURLLoaderForTest(url_loader_);
 
     data_source_->Initialize(url, callback);
     MessageLoop::current()->RunAllPending();
   }
 
   void RequestSucceeded(bool is_loaded) {
@@ skipping 27 matching lines @@
     WebURLError error;
     error.reason = net::ERR_FAILED;
     data_source_->didFail(NULL, error);
 
     // Let the tasks to be executed.
     MessageLoop::current()->RunAllPending();
   }
 
   void Redirect(const char* url) {
     GURL redirectUrl(url);
-    WebKit::WebURLRequest newRequest(redirectUrl);
-    WebKit::WebURLResponse redirectResponse(gurl_);
+    WebURLRequest newRequest(redirectUrl);
+    WebURLResponse redirectResponse(gurl_);
 
     data_source_->willSendRequest(url_loader_, newRequest, redirectResponse);
 
     MessageLoop::current()->RunAllPending();
   }
 
   void DestroyDataSource() {
     data_source_->Stop(media::NewExpectedCallback());
     MessageLoop::current()->RunAllPending();
 
@@ skipping 13 matching lines @@
   }
 
   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_;
-  scoped_ptr<NiceMock<MockWebFrame> > frame_;
+
+  MockWebFrameClient client_;
+  WebView* view_;
 
   char data_[kDataSize];
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDataSourceTest);
 };
 
 TEST_F(SimpleDataSourceTest, InitializeHTTP) {
   InitializeDataSource(kHttpUrl,
                        media::NewExpectedStatusCallback(media::PIPELINE_OK));
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeHTTPS) {
   InitializeDataSource(kHttpsUrl,
                        media::NewExpectedStatusCallback(media::PIPELINE_OK));
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeFile) {
   InitializeDataSource(kFileUrl,
                        media::NewExpectedStatusCallback(media::PIPELINE_OK));
   RequestSucceeded(true);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeData) {
-  frame_.reset(new NiceMock<MockWebFrame>());
+  view_ = WebView::create(NULL);
+  view_->initializeMainFrame(&client_);
+
   url_loader_ = new NiceMock<MockWebURLLoader>();
 
   data_source_ = new SimpleDataSource(MessageLoop::current(),
-                                      frame_.get());
+                                      view_->mainFrame());
   // 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)));
 
   data_source_->Initialize(kDataUrl,
       media::NewExpectedStatusCallback(media::PIPELINE_OK));
@@ skipping 70 matching lines @@
   InitializeDataSource(kHttpUrl,
                        media::NewExpectedStatusCallback(media::PIPELINE_OK));
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   RequestSucceeded(false);
   EXPECT_FALSE(data_source_->HasSingleOrigin());
   DestroyDataSource();
 }
 
 }  // namespace webkit_glue