Cleanup more test code.

BUG=none
TEST=compiles

Review URL: http://codereview.chromium.org/6462015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@74328 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 518 insertions, 249 deletions

diff --git a/webkit/mocks/mock_webframe.cc b/webkit/mocks/mock_webframe.cc
new file mode 100644
index 0000000..cf382c3
--- /dev/null
+++ b/webkit/mocks/mock_webframe.cc
@@ -0,0 +1,393 @@
+// 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 "webkit/mocks/mock_webframe.h"
+
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
+
+namespace webkit_glue {
+
+MockWebFrame::MockWebFrame() {}
+
+MockWebFrame::~MockWebFrame() {}
+
+WebString MockWebFrame::name() const {
+  return WebString();
+}
+
+void MockWebFrame::setName(const WebString&) {}
+
+long long MockWebFrame::identifier() const {
+  return 0;
+}
+
+WebURL MockWebFrame::url() const {
+  return WebURL();
+}
+
+WebURL MockWebFrame::favIconURL() const {
+  return WebURL();
+}
+
+WebURL MockWebFrame::openSearchDescriptionURL() const {
+  return WebURL();
+}
+
+WebString MockWebFrame::encoding() const {
+  return WebString();
+}
+
+void MockWebFrame::setCanHaveScrollbars(bool) {}
+
+WebSize MockWebFrame::scrollOffset() const {
+  return WebSize(0,0);
+}
+
+WebSize MockWebFrame::contentsSize() const {
+  return WebSize();
+}
+
+int MockWebFrame::contentsPreferredWidth() const {
+  return 0;
+}
+
+int MockWebFrame::documentElementScrollHeight() const {
+  return 0;
+}
+
+bool MockWebFrame::hasVisibleContent() const {
+  return false;
+}
+
+WebView* MockWebFrame::view() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::opener() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::parent() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::top() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::firstChild() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::lastChild() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::nextSibling() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::previousSibling() const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::traverseNext(bool wrap) const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::traversePrevious(bool wrap) const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::findChildByName(const WebString& name) const {
+  return NULL;
+}
+
+WebFrame* MockWebFrame::findChildByExpression(const WebString& xpath) const {
+  return NULL;
+}
+
+WebDocument MockWebFrame::document() const {
+  return WebDocument();
+}
+
+void MockWebFrame::forms(WebVector<WebFormElement>&) const {}
+
+WebAnimationController* MockWebFrame::animationController() {
+  return NULL;
+}
+
+WebPerformance MockWebFrame::performance() const {
+  return WebPerformance();
+}
+
+WebSecurityOrigin MockWebFrame::securityOrigin() const {
+  return WebSecurityOrigin();
+}
+
+void MockWebFrame::grantUniversalAccess() {}
+
+NPObject* MockWebFrame::windowObject() const {
+  return NULL;
+}
+
+void MockWebFrame::bindToWindowObject(const WebString& name, NPObject*) {}
+
+void MockWebFrame::executeScript(const WebScriptSource&) {}
+
+void MockWebFrame::executeScriptInIsolatedWorld(
+    int worldId, const WebScriptSource* sources, unsigned numSources,
+    int extensionGroup) {}
+
+void MockWebFrame::addMessageToConsole(const WebConsoleMessage&) {}
+
+void MockWebFrame::collectGarbage() {}
+
+#if WEBKIT_USING_V8
+v8::Handle<v8::Value> MockWebFrame::executeScriptAndReturnValue(
+    const WebScriptSource&) {
+  return v8::Handle<v8::Value>();
+}
+
+v8::Local<v8::Context> MockWebFrame::mainWorldScriptContext() const {
+  return v8::Local<v8::Context>();
+}
+#endif
+
+
+bool MockWebFrame::insertStyleText(const WebString& styleText,
+                                   const WebString& elementId) {
+  return false;
+}
+
+void MockWebFrame::reload(bool ignoreCache) {}
+
+void MockWebFrame::loadRequest(const WebURLRequest&) {}
+
+void MockWebFrame::loadHistoryItem(const WebHistoryItem&) {}
+
+void MockWebFrame::loadData(const WebData& data,
+                            const WebString& mimeType,
+                            const WebString& textEncoding,
+                            const WebURL& baseURL,
+                            const WebURL& unreachableURL,
+                            bool replace) {}
+
+void MockWebFrame::loadHTMLString(const WebData& html,
+                                  const WebURL& baseURL,
+                                  const WebURL& unreachableURL,
+                                  bool replace) {}
+
+bool MockWebFrame::isLoading() const {
+  return false;
+}
+
+void MockWebFrame::stopLoading() {}
+
+WebKit::WebDataSource* MockWebFrame::provisionalDataSource() const {
+  return NULL;
+}
+
+WebKit::WebDataSource* MockWebFrame::dataSource() const {
+  return NULL;
+}
+
+WebHistoryItem MockWebFrame::previousHistoryItem() const {
+  return WebHistoryItem();
+}
+
+WebHistoryItem MockWebFrame::currentHistoryItem() const {
+  return WebHistoryItem();
+}
+
+void MockWebFrame::enableViewSourceMode(bool) {}
+
+bool MockWebFrame::isViewSourceModeEnabled() const {
+  return false;
+}
+
+WebURLLoader* MockWebFrame::createAssociatedURLLoader() {
+  return NULL;
+}
+
+void MockWebFrame::commitDocumentData(const char* data, size_t length) {}
+
+unsigned MockWebFrame::unloadListenerCount() const {
+  return 0;
+}
+
+bool MockWebFrame::isProcessingUserGesture() const {
+  return false;
+}
+
+bool MockWebFrame::willSuppressOpenerInNewFrame() const {
+  return false;
+}
+
+void MockWebFrame::replaceSelection(const WebString& text) {}
+
+void MockWebFrame::insertText(const WebString& text) {}
+
+void MockWebFrame::setMarkedText(const WebString& text,
+                                 unsigned location,
+                                 unsigned length) {}
+
+void MockWebFrame::unmarkText() {}
+
+bool MockWebFrame::hasMarkedText() const {
+  return false;
+}
+
+WebRange MockWebFrame::markedRange() const {
+  return WebRange();
+}
+
+bool MockWebFrame::firstRectForCharacterRange(unsigned location,
+                                              unsigned length,
+                                              WebRect&) const {
+  return false;
+}
+
+bool MockWebFrame::executeCommand(const WebString&) {
+  return false;
+}
+
+bool MockWebFrame::executeCommand(const WebString&, const WebString& value) {
+  return false;
+}
+
+bool MockWebFrame::isCommandEnabled(const WebString&) const {
+  return false;
+}
+
+void MockWebFrame::enableContinuousSpellChecking(bool) {}
+
+bool MockWebFrame::isContinuousSpellCheckingEnabled() const {
+  return false;
+}
+
+bool MockWebFrame::hasSelection() const {
+  return false;
+}
+
+WebRange MockWebFrame::selectionRange() const {
+  return WebRange();
+}
+
+WebString MockWebFrame::selectionAsText() const {
+  return WebString();
+}
+
+WebString MockWebFrame::selectionAsMarkup() const {
+  return WebString();
+}
+
+bool MockWebFrame::selectWordAroundCaret() {
+  return false;
+}
+
+int MockWebFrame::printBegin(const WebSize& pageSize,
+                             const WebNode& constrainToNode,
+                             int printerDPI,
+                             bool* useBrowserOverlays) {
+  return 0;
+}
+
+float MockWebFrame::getPrintPageShrink(int page) {
+  return 0;
+}
+
+float MockWebFrame::printPage(int pageToPrint, WebCanvas*) {
+  return 0;
+}
+
+void MockWebFrame::printEnd() {}
+
+bool MockWebFrame::isPageBoxVisible(int pageIndex) {
+  return false;
+}
+
+void MockWebFrame::pageSizeAndMarginsInPixels(int pageIndex,
+                                              WebSize& pageSize,
+                                              int& marginTop,
+                                              int& marginRight,
+                                              int& marginBottom,
+                                              int& marginLeft) {}
+
+bool MockWebFrame::find(int identifier,
+                        const WebString& searchText,
+                        const WebFindOptions& options,
+                        bool wrapWithinFrame,
+                        WebRect* selectionRect) {
+  return false;
+}
+
+void MockWebFrame::stopFinding(bool clearSelection) {}
+
+void MockWebFrame::scopeStringMatches(int identifier,
+                                      const WebString& searchText,
+                                      const WebFindOptions& options,
+                                      bool reset) {}
+
+void MockWebFrame::cancelPendingScopingEffort() {}
+
+void MockWebFrame::increaseMatchCount(int count, int identifier) {}
+
+void MockWebFrame::resetMatchCount() {}
+
+bool MockWebFrame::registerPasswordListener(
+    WebInputElement,
+    WebPasswordAutocompleteListener*) {
+  return false;
+}
+
+void MockWebFrame::notifiyPasswordListenerOfAutocomplete(
+    const WebInputElement&) {}
+
+WebString MockWebFrame::contentAsText(size_t maxChars) const {
+  return WebString();
+}
+
+WebString MockWebFrame::contentAsMarkup() const {
+  return WebString();
+}
+
+WebString MockWebFrame::renderTreeAsText() const {
+  return WebString();
+}
+
+WebString MockWebFrame::counterValueForElementById(const WebString& id) const {
+  return WebString();
+}
+
+WebString MockWebFrame::markerTextForListItem(const WebElement&) const {
+  return WebString();
+}
+
+int MockWebFrame::pageNumberForElementById(const WebString& id,
+                                           float pageWidthInPixels,
+                                           float pageHeightInPixels) const {
+  return 0;
+}
+
+WebRect MockWebFrame::selectionBoundsRect() const {
+  return WebRect();
+}
+
+bool MockWebFrame::selectionStartHasSpellingMarkerFor(int from,
+                                                      int length) const {
+  return false;
+}
+
+bool MockWebFrame::pauseSVGAnimation(const WebString& animationId,
+                                     double time,
+                                     const WebString& elementId) {
+  return false;
+}
+
+WebString MockWebFrame::layerTreeAsText() const {
+  return WebString();
+}
+
+}  // namespace webkit_glue
diff --git a/webkit/mocks/mock_webframe.h b/webkit/mocks/mock_webframe.h
index bf65c5c..e49029d 100644
--- a/webkit/mocks/mock_webframe.h
+++ b/webkit/mocks/mock_webframe.h
@@ -1,4 +1,4 @@
-// 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.
 
@@ -48,11 +48,8 @@ namespace webkit_glue {
 
 class MockWebFrame : public WebKit::WebFrame {
  public:
-  MockWebFrame() {
-  }
-
-  virtual ~MockWebFrame() {
-  }
+  MockWebFrame();
+  virtual ~MockWebFrame();
 
   MOCK_METHOD2(setReferrerForRequest, void(WebURLRequest&, const WebURL&));
   MOCK_METHOD1(dispatchWillSendRequest, void(WebURLRequest&));
@@ -65,286 +62,148 @@ class MockWebFrame : public WebKit::WebFrame {
     return NULL;
   }
 
-  virtual WebString name() const {
-    return WebString();
-  }
-  virtual void setName(const WebString&) {}
-  virtual long long identifier() const {
-    return 0;
-  }
-  virtual WebURL url() const {
-    return WebURL();
-  }
-  virtual WebURL favIconURL() const {
-    return WebURL();
-  }
-  virtual WebURL openSearchDescriptionURL() const {
-    return WebURL();
-  }
-  virtual WebString encoding() const {
-    return WebString();
-  }
-  virtual void setCanHaveScrollbars(bool) {}
-  virtual WebSize scrollOffset() const {
-    return WebSize(0,0);
-  }
-  virtual WebSize contentsSize() const {
-     return WebSize();
-  }
-  virtual int contentsPreferredWidth() const {
-    return 0;
-  }
-  virtual int documentElementScrollHeight() const {
-    return 0;
-  }
-  virtual bool hasVisibleContent() const {
-    return false;
-  }
-  virtual WebView* view() const {
-    return NULL;
-  }
-  virtual WebFrame* opener() const {
-    return NULL;
-  }
-  virtual WebFrame* parent() const {
-    return NULL;
-  }
-  virtual WebFrame* top() const {
-    return NULL;
-  }
-  virtual WebFrame* firstChild() const {
-    return NULL;
-  }
-  virtual WebFrame* lastChild() const {
-    return NULL;
-  }
-  virtual WebFrame* nextSibling() const {
-    return NULL;
-  }
-  virtual WebFrame* previousSibling() const {
-    return NULL;
-  }
-  virtual WebFrame* traverseNext(bool wrap) const {
-    return NULL;
-  }
-  virtual WebFrame* traversePrevious(bool wrap) const {
-    return NULL;
-  }
-  virtual WebFrame* findChildByName(const WebString& name) const {
-    return NULL;
-  }
-  virtual WebFrame* findChildByExpression(const WebString& xpath) const {
-    return NULL;
-  }
-  virtual WebDocument document() const {
-    return WebDocument();
-  }
-  virtual void forms(WebVector<WebFormElement>&) const {}
-  virtual WebAnimationController* animationController() {
-    return NULL;
-  }
-  virtual WebPerformance performance() const {
-    return WebPerformance();
-  }
-  virtual WebSecurityOrigin securityOrigin() const {
-    return WebSecurityOrigin();
-  }
-  virtual void grantUniversalAccess() {}
-  virtual NPObject* windowObject() const {
-    return NULL;
-  }
-  virtual void bindToWindowObject(const WebString& name, NPObject*) {}
-  virtual void executeScript(const WebScriptSource&) {}
+  virtual WebString name() const;
+  virtual void setName(const WebString&);
+  virtual long long identifier() const;
+  virtual WebURL url() const;
+  virtual WebURL favIconURL() const;
+  virtual WebURL openSearchDescriptionURL() const;
+  virtual WebString encoding() const;
+  virtual void setCanHaveScrollbars(bool);
+  virtual WebSize scrollOffset() const;
+  virtual WebSize contentsSize() const;
+  virtual int contentsPreferredWidth() const;
+  virtual int documentElementScrollHeight() const;
+  virtual bool hasVisibleContent() const;
+  virtual WebView* view() const;
+  virtual WebFrame* opener() const;
+  virtual WebFrame* parent() const;
+  virtual WebFrame* top() const;
+  virtual WebFrame* firstChild() const;
+  virtual WebFrame* lastChild() const;
+  virtual WebFrame* nextSibling() const;
+  virtual WebFrame* previousSibling() const;
+  virtual WebFrame* traverseNext(bool wrap) const;
+  virtual WebFrame* traversePrevious(bool wrap) const;
+  virtual WebFrame* findChildByName(const WebString& name) const;
+  virtual WebFrame* findChildByExpression(const WebString& xpath) const;
+  virtual WebDocument document() const;
+  virtual void forms(WebVector<WebFormElement>&) const;
+  virtual WebAnimationController* animationController();
+  virtual WebPerformance performance() const;
+  virtual WebSecurityOrigin securityOrigin() const;
+  virtual void grantUniversalAccess();
+  virtual NPObject* windowObject() const;
+  virtual void bindToWindowObject(const WebString& name, NPObject*);
+  virtual void executeScript(const WebScriptSource&);
   virtual void executeScriptInIsolatedWorld(
       int worldId, const WebScriptSource* sources, unsigned numSources,
-      int extensionGroup) {}
-  virtual void addMessageToConsole(const WebConsoleMessage&) {}
-  virtual void collectGarbage() {}
+      int extensionGroup);
+  virtual void addMessageToConsole(const WebConsoleMessage&);
+  virtual void collectGarbage();
 #if WEBKIT_USING_V8
   virtual v8::Handle<v8::Value> executeScriptAndReturnValue(
-      const WebScriptSource&) {
-    return v8::Handle<v8::Value>();
-  }
-  virtual v8::Local<v8::Context> mainWorldScriptContext() const {
-    return v8::Local<v8::Context>();
-  }
+      const WebScriptSource&);
+  virtual v8::Local<v8::Context> mainWorldScriptContext() const;
 #endif
   virtual bool insertStyleText(const WebString& styleText,
-                               const WebString& elementId) {
-    return false;
-  }
-  virtual void reload(bool ignoreCache = false) {}
-  virtual void loadRequest(const WebURLRequest&) {}
-  virtual void loadHistoryItem(const WebHistoryItem&) {}
+                               const WebString& elementId);
+  virtual void reload(bool ignoreCache = false);
+  virtual void loadRequest(const WebURLRequest&);
+  virtual void loadHistoryItem(const WebHistoryItem&);
   virtual void loadData(const WebData& data,
                         const WebString& mimeType,
                         const WebString& textEncoding,
                         const WebURL& baseURL,
                         const WebURL& unreachableURL = WebURL(),
-                        bool replace = false) {}
+                        bool replace = false);
   virtual void loadHTMLString(const WebData& html,
                               const WebURL& baseURL,
                               const WebURL& unreachableURL = WebURL(),
-                              bool replace = false) {}
-  virtual bool isLoading() const {
-    return false;
-  }
-  virtual void stopLoading() {}
-  virtual WebKit::WebDataSource* provisionalDataSource() const {
-    return NULL;
-  }
-  virtual WebKit::WebDataSource* dataSource() const {
-    return NULL;
-  }
-  virtual WebHistoryItem previousHistoryItem() const {
-    return WebHistoryItem();
-  }
-  virtual WebHistoryItem currentHistoryItem() const {
-    return WebHistoryItem();
-  }
-  virtual void enableViewSourceMode(bool) {}
-  virtual bool isViewSourceModeEnabled() const {
-    return false;
-  }
+                              bool replace = false);
+  virtual bool isLoading() const;
+  virtual void stopLoading();
+  virtual WebKit::WebDataSource* provisionalDataSource() const;
+  virtual WebKit::WebDataSource* dataSource() const;
+  virtual WebHistoryItem previousHistoryItem() const;
+  virtual WebHistoryItem currentHistoryItem() const;
+  virtual void enableViewSourceMode(bool);
+  virtual bool isViewSourceModeEnabled() const;
   // The next two methods were mocked above.
   // virtual void setReferrerForRequest(WebURLRequest&, const WebURL&) {}
   // virtual void dispatchWillSendRequest(WebURLRequest&) {}
-  virtual WebURLLoader* createAssociatedURLLoader() {
-    return NULL;
-  }
-  virtual void commitDocumentData(const char* data, size_t length) {}
-  virtual unsigned unloadListenerCount() const {
-    return 0;
-  }
-  virtual bool isProcessingUserGesture() const {
-    return false;
-  }
-  virtual bool willSuppressOpenerInNewFrame() const {
-    return false;
-  }
-  virtual void replaceSelection(const WebString& text) {}
-  virtual void insertText(const WebString& text) {}
+  virtual WebURLLoader* createAssociatedURLLoader();
+  virtual void commitDocumentData(const char* data, size_t length);
+  virtual unsigned unloadListenerCount() const;
+  virtual bool isProcessingUserGesture() const;
+  virtual bool willSuppressOpenerInNewFrame() const;
+  virtual void replaceSelection(const WebString& text);
+  virtual void insertText(const WebString& text);
   virtual void setMarkedText(const WebString& text,
                              unsigned location,
-                             unsigned length) {}
-  virtual void unmarkText() {}
-  virtual bool hasMarkedText() const {
-    return false;
-  }
-  virtual WebRange markedRange() const {
-    return WebRange();
-  }
+                             unsigned length);
+  virtual void unmarkText();
+  virtual bool hasMarkedText() const;
+  virtual WebRange markedRange() const;
   virtual bool firstRectForCharacterRange(unsigned location,
                                           unsigned length,
-                                          WebRect&) const {
-    return false;
-  }
-  virtual bool executeCommand(const WebString&) {
-    return false;
-  }
-  virtual bool executeCommand(const WebString&, const WebString& value) {
-    return false;
-  }
-  virtual bool isCommandEnabled(const WebString&) const {
-    return false;
-  }
-  virtual void enableContinuousSpellChecking(bool) {}
-  virtual bool isContinuousSpellCheckingEnabled() const {
-    return false;
-  }
-  virtual bool hasSelection() const {
-    return false;
-  }
-  virtual WebRange selectionRange() const {
-    return WebRange();
-  }
-  virtual WebString selectionAsText() const {
-    return WebString();
-  }
-  virtual WebString selectionAsMarkup() const {
-    return WebString();
-  }
-  virtual bool selectWordAroundCaret() {
-    return false;
-  }
+                                          WebRect&) const;
+  virtual bool executeCommand(const WebString&);
+  virtual bool executeCommand(const WebString&, const WebString& value);
+  virtual bool isCommandEnabled(const WebString&) const;
+  virtual void enableContinuousSpellChecking(bool);
+  virtual bool isContinuousSpellCheckingEnabled() const;
+  virtual bool hasSelection() const;
+  virtual WebRange selectionRange() const;
+  virtual WebString selectionAsText() const;
+  virtual WebString selectionAsMarkup() const;
+  virtual bool selectWordAroundCaret();
   virtual int printBegin(const WebSize& pageSize,
                          const WebNode& constrainToNode,
                          int printerDPI = 72,
-                         bool* useBrowserOverlays = 0) {
-    return 0;
-  }
-  virtual float getPrintPageShrink(int page) {
-    return 0;
-  }
-  virtual float printPage(int pageToPrint, WebCanvas*) {
-    return 0;
-  }
-  virtual void printEnd() {}
-  virtual bool isPageBoxVisible(int pageIndex) {
-    return false;
-  }
+                         bool* useBrowserOverlays = 0);
+  virtual float getPrintPageShrink(int page);
+  virtual float printPage(int pageToPrint, WebCanvas*);
+  virtual void printEnd();
+  virtual bool isPageBoxVisible(int pageIndex);
   virtual void pageSizeAndMarginsInPixels(int pageIndex,
                                           WebSize& pageSize,
                                           int& marginTop,
                                           int& marginRight,
                                           int& marginBottom,
-                                          int& marginLeft) {}
+                                          int& marginLeft);
   virtual bool find(int identifier,
                     const WebString& searchText,
                     const WebFindOptions& options,
                     bool wrapWithinFrame,
-                    WebRect* selectionRect) {
-    return false;
-  }
-  virtual void stopFinding(bool clearSelection) {}
+                    WebRect* selectionRect);
+  virtual void stopFinding(bool clearSelection);
   virtual void scopeStringMatches(int identifier,
                                   const WebString& searchText,
                                   const WebFindOptions& options,
-                                  bool reset) {}
-  virtual void cancelPendingScopingEffort() {}
-  virtual void increaseMatchCount(int count, int identifier) {}
-  virtual void resetMatchCount() {}
+                                  bool reset);
+  virtual void cancelPendingScopingEffort();
+  virtual void increaseMatchCount(int count, int identifier);
+  virtual void resetMatchCount();
   virtual bool registerPasswordListener(
       WebInputElement,
-      WebPasswordAutocompleteListener*) {
-    return false;
-  }
+      WebPasswordAutocompleteListener*);
   virtual void notifiyPasswordListenerOfAutocomplete(
-      const WebInputElement&) {}
-  virtual WebString contentAsText(size_t maxChars) const {
-    return WebString();
-  }
-  virtual WebString contentAsMarkup() const {
-    return WebString();
-  }
-  virtual WebString renderTreeAsText() const {
-    return WebString();
-  }
-  virtual WebString counterValueForElementById(const WebString& id) const {
-    return WebString();
-  }
-  virtual WebString markerTextForListItem(const WebElement&) const {
-    return WebString();
-  }
+      const WebInputElement&);
+  virtual WebString contentAsText(size_t maxChars) const;
+  virtual WebString contentAsMarkup() const;
+  virtual WebString renderTreeAsText() const;
+  virtual WebString counterValueForElementById(const WebString& id) const;
+  virtual WebString markerTextForListItem(const WebElement&) const;
   virtual int pageNumberForElementById(const WebString& id,
                                        float pageWidthInPixels,
-                                       float pageHeightInPixels) const {
-    return 0;
-  }
-  virtual WebRect selectionBoundsRect() const {
-    return WebRect();
-  }
-  virtual bool selectionStartHasSpellingMarkerFor(int from, int length) const {
-    return false;
-  }
+                                       float pageHeightInPixels) const;
+  virtual WebRect selectionBoundsRect() const;
+  virtual bool selectionStartHasSpellingMarkerFor(int from, int length) const;
   virtual bool pauseSVGAnimation(const WebString& animationId,
                                  double time,
-                                 const WebString& elementId) {
-    return false;
-  }
-  virtual WebString layerTreeAsText() const {
-    return WebString();
-  }
+                                 const WebString& elementId);
+  virtual WebString layerTreeAsText() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockWebFrame);
diff --git a/webkit/mocks/mock_weburlloader.cc b/webkit/mocks/mock_weburlloader.cc
new file mode 100644
index 0000000..7610c19
--- /dev/null
+++ b/webkit/mocks/mock_weburlloader.cc
@@ -0,0 +1,18 @@
+// 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 "webkit/mocks/mock_weburlloader.h"
+
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebData.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/WebURLRequest.h"
+
+namespace webkit_glue {
+
+MockWebURLLoader::MockWebURLLoader() {}
+
+MockWebURLLoader::~MockWebURLLoader() {}
+
+}  // namespace webkit_glue
diff --git a/webkit/mocks/mock_weburlloader.h b/webkit/mocks/mock_weburlloader.h
index 7253faa..68ff9a2 100644
--- a/webkit/mocks/mock_weburlloader.h
+++ b/webkit/mocks/mock_weburlloader.h
@@ -1,4 +1,4 @@
-// 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.
 
@@ -12,11 +12,8 @@ namespace webkit_glue {
 
 class MockWebURLLoader : public WebKit::WebURLLoader {
  public:
-  MockWebURLLoader() {
-  }
-
-  virtual ~MockWebURLLoader() {
-  }
+  MockWebURLLoader();
+  virtual ~MockWebURLLoader();
 
   MOCK_METHOD4(loadSynchronously, void(const WebKit::WebURLRequest& request,
                                        WebKit::WebURLResponse& response,
diff --git a/webkit/tools/test_shell/test_shell.gypi b/webkit/tools/test_shell/test_shell.gypi
index 6a2d336..159fc68 100644
--- a/webkit/tools/test_shell/test_shell.gypi
+++ b/webkit/tools/test_shell/test_shell.gypi
@@ -403,7 +403,9 @@
         '../../glue/webpasswordautocompletelistener_unittest.cc',
         '../../glue/webview_unittest.cc',
         '../../mocks/mock_resource_loader_bridge.h',
+        '../../mocks/mock_webframe.cc',
         '../../mocks/mock_webframe.h',
+        '../../mocks/mock_weburlloader.cc',
         '../../mocks/mock_weburlloader.h',
         '../../plugins/npapi/plugin_group_unittest.cc',
         '../../plugins/npapi/plugin_lib_unittest.cc',