Remove MockWebFrame in favour of MockWebFrameClient and update corresponding tests.

webkit/glue/media/buffered_resource_loader_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 <algorithm>
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrameClient.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.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/buffered_resource_loader.h"
-#include "webkit/mocks/mock_webframe.h"
+#include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::AtLeast;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::NiceMock;
 using ::testing::WithArgs;
 
+using WebKit::WebString;
 using WebKit::WebURLError;
-using WebKit::WebFrameClient;
 using WebKit::WebURLResponse;
 using WebKit::WebView;
 
 namespace webkit_glue {
 
 static const char* kHttpUrl = "http://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";
@@ skipping 12 matching lines @@
 // being canceled. Pretending the event is from external.
 ACTION_P(RequestCanceled, loader) {
   WebURLError error;
   error.reason = net::ERR_ABORTED;
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   loader->didFail(NULL, error);
 }
 
 class BufferedResourceLoaderTest : public testing::Test {
  public:
-  BufferedResourceLoaderTest() {
+  BufferedResourceLoaderTest()
+      : view_(NULL) {
     for (int i = 0; i < kDataSize; ++i)
       data_[i] = i;
   }
 
   virtual ~BufferedResourceLoaderTest() {
+    if (view_) {

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

nit: braces not necessary

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

Done.

+      view_->close();
+    }
   }
 
   void Initialize(const char* url, int first_position, int last_position) {
     gurl_ = GURL(url);
     first_position_ = first_position;
     last_position_ = last_position;
 
-    frame_.reset(new NiceMock<MockWebFrame>());
+    view_ = WebView::create(NULL);
+    view_->initializeMainFrame(&client_);
 
     url_loader_ = new NiceMock<MockWebURLLoader>();
     loader_ = new BufferedResourceLoader(gurl_,
                                          first_position_, last_position_);
     loader_->SetURLLoaderForTest(url_loader_);
   }
 
   void SetLoaderBuffer(size_t forward_capacity, size_t backward_capacity) {
     loader_->buffer_.reset(
         new media::SeekableBuffer(backward_capacity, forward_capacity));
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(*url_loader_, loadAsynchronously(_, loader_.get()));
     loader_->Start(
         NewCallback(this, &BufferedResourceLoaderTest::StartCallback),
         NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback),
-        frame_.get());
+        view_->mainFrame());
   }
 
   void FullResponse(int64 instance_size) {
     FullResponse(instance_size, net::OK);
   }
 
   void FullResponse(int64 instance_size, int status) {
     EXPECT_CALL(*this, StartCallback(status));
     if (status != net::OK) {
       EXPECT_CALL(*url_loader_, cancel())
@@ skipping 111 matching lines @@
   MOCK_METHOD1(ReadCallback, void(int error));
   MOCK_METHOD0(NetworkCallback, void());
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
 
   scoped_refptr<BufferedResourceLoader> loader_;
   NiceMock<MockWebURLLoader>* url_loader_;
-  scoped_ptr<NiceMock<MockWebFrame> > frame_;
+
+  MockWebFrameClient client_;
+  WebView* view_;
 
   uint8 data_[kDataSize];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoaderTest);
 };
 
 TEST_F(BufferedResourceLoaderTest, StartStop) {
   Initialize(kHttpUrl, -1, -1);
   Start();
@@ skipping 298 matching lines @@
   Start();
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   EXPECT_FALSE(loader_->HasSingleOrigin());
   StopWhenLoad();
 }
 
 // TODO(hclam): add unit test for defer loading.
 
 }  // namespace webkit_glue