Remove unneeded code from WebTestProxyBase.

components/test_runner/web_test_proxy.cc

 // Copyright 2014 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 "components/test_runner/web_test_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cctype>
@@ skipping 284 matching lines @@
   std::string result;
   const std::vector<WebTestProxyBase*>& window_list =
       interfaces->GetWindowList();
   for (size_t i = 0; i < window_list.size(); ++i)
     result.append(delegate->DumpHistoryForWindow(window_list.at(i)));
   return result;
 }
 }
 
 WebTestProxyBase::WebTestProxyBase()
-    : web_test_interfaces_(NULL),
-      test_interfaces_(NULL),
+    : test_interfaces_(NULL),
       delegate_(NULL),
       web_widget_(NULL),
       spellcheck_(new SpellCheckClient(this)),
       chooser_count_(0) {
   Reset();
 }
 
 WebTestProxyBase::~WebTestProxyBase() {
   test_interfaces_->WindowClosed(this);
-  delegate_->OnWebTestProxyBaseDestroy(this);
 }
 
 void WebTestProxyBase::SetInterfaces(WebTestInterfaces* interfaces) {
-  web_test_interfaces_ = interfaces;
   test_interfaces_ = interfaces->GetTestInterfaces();
   test_interfaces_->WindowOpened(this);
 }
 
-WebTestInterfaces* WebTestProxyBase::GetInterfaces() {
-  return web_test_interfaces_;
-}
-
 void WebTestProxyBase::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   spellcheck_->SetDelegate(delegate);
   if (speech_recognizer_.get())
     speech_recognizer_->SetDelegate(delegate);
 }
 
-WebTestDelegate* WebTestProxyBase::GetDelegate() {
-  return delegate_;
-}
-
 blink::WebView* WebTestProxyBase::GetWebView() const {
   DCHECK(web_widget_);
   // TestRunner does not support popup widgets. So |web_widget|_ is always a
   // WebView.
   return static_cast<blink::WebView*>(web_widget_);
 }
 
 void WebTestProxyBase::Reset() {
   drag_image_.reset();
   animate_scheduled_ = false;
@@ skipping 45 matching lines @@
     } else if (sub_message_hint == blink::WebTextDirectionRightToLeft) {
       base::i18n::WrapStringWithRTLFormatting(&wrapped_sub_text);
     }
   }
   delegate_->PrintMessage("ValidationMessageClient: main-message=" +
                           base::UTF16ToUTF8(wrapped_main_text) +
                           " sub-message=" +
                           base::UTF16ToUTF8(wrapped_sub_text) + "\n");
 }
 
+void WebTestProxyBase::RunModalAlertDialog(const blink::WebString& message) {
+  delegate_->PrintMessage(std::string("ALERT: ") + message.utf8().data() +
+                          "\n");
+}
+
+bool WebTestProxyBase::RunModalConfirmDialog(const blink::WebString& message) {
+  delegate_->PrintMessage(std::string("CONFIRM: ") + message.utf8().data() +
+                          "\n");
+  return true;
+}
+
+bool WebTestProxyBase::RunModalPromptDialog(
+    const blink::WebString& message,
+    const blink::WebString& default_value,
+    blink::WebString* actual_value) {
+  delegate_->PrintMessage(std::string("PROMPT: ") + message.utf8().data() +
+                          ", default text: " + default_value.utf8().data() +
+                          "\n");
+  return true;
+}
+
+bool WebTestProxyBase::RunModalBeforeUnloadDialog(bool is_reload) {
+  delegate_->PrintMessage(std::string("CONFIRM NAVIGATION\n"));
+  return !test_interfaces_->GetTestRunner()
+      ->shouldStayOnPageAfterHandlingBeforeUnload();
+}
+
 std::string WebTestProxyBase::DumpBackForwardLists() {
   return DumpAllBackForwardLists(test_interfaces_, delegate_);
 }
 
 void WebTestProxyBase::DrawSelectionRect(SkCanvas* canvas) {
   // See if we need to draw the selection bounds rect. Selection bounds
   // rect is the rect enclosing the (possibly transformed) selection.
   // The rect should be drawn after everything is laid out and painted.
   if (!test_interfaces_->GetTestRunner()->shouldDumpSelectionRect())
     return;
@@ skipping 881 matching lines @@
     callback->onError(blink::WebSetSinkIdError::NotAuthorized);
   else
     callback->onError(blink::WebSetSinkIdError::NotFound);
 }
 
 blink::WebString WebTestProxyBase::acceptLanguages() {
   return blink::WebString::fromUTF8(accept_languages_);
 }
 
 }  // namespace test_runner