Update WebFrameTestProxy and WebTestProxy to mostly follow Chrome style.

content/shell/renderer/test_runner/test_runner.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 "content/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/shell/common/test_runner/test_preferences.h"
 #include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
 #include "content/shell/renderer/test_runner/TestInterfaces.h"
 #include "content/shell/renderer/test_runner/WebPermissions.h"
 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
-#include "content/shell/renderer/test_runner/WebTestProxy.h"
 #include "content/shell/renderer/test_runner/notification_presenter.h"
+#include "content/shell/renderer/test_runner/web_test_proxy.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "third_party/WebKit/public/platform/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
 #include "third_party/WebKit/public/platform/WebDeviceOrientationData.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
@@ skipping 1723 matching lines @@
 
  private:
   int distance_;
 };
 
 void TestRunner::NotifyDone() {
   if (disable_notify_done_)
     return;
 
   // Test didn't timeout. Kill the timeout timer.
-  taskList()->revokeAll();
+  task_list_.revokeAll();
 
   CompleteNotifyDone();
 }
 
 void TestRunner::WaitUntilDone() {
   wait_until_done_ = true;
 }
 
 void TestRunner::QueueBackNavigation(int how_far_back) {
   work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
@@ skipping 694 matching lines @@
 
 void TestRunner::WaitUntilExternalURLLoad() {
   wait_until_external_url_load_ = true;
 }
 
 void TestRunner::CloseWebInspector() {
   delegate_->closeDevTools();
 }
 
 bool TestRunner::IsChooserShown() {
-  return proxy_->isChooserShown();
+  return proxy_->IsChooserShown();
 }
 
 void TestRunner::EvaluateInWebInspector(int call_id,
                                         const std::string& script) {
   delegate_->evaluateInWebInspector(call_id, script);
 }
 
 void TestRunner::ClearAllDatabases() {
   delegate_->clearAllDatabases();
 }
@@ skipping 10 matching lines @@
   delegate_->setFocus(proxy_, value);
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
   return delegate_->pathToLocalResource(path);
 }
 
 void TestRunner::SetBackingScaleFactor(double value,
                                        v8::Handle<v8::Function> callback) {
   delegate_->setDeviceScaleFactor(value);
-  proxy_->discardBackingStore();
+  proxy_->DiscardBackingStore();
   delegate_->postTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetColorProfile(const std::string& name,
                                  v8::Handle<v8::Function> callback) {
   delegate_->setDeviceColorProfile(name);
   delegate_->postTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetPOSIXLocale(const std::string& locale) {
   delegate_->setLocale(locale);
 }
 
 void TestRunner::SetMIDIAccessorResult(bool result) {
   midi_accessor_result_ = result;
 }
 
 void TestRunner::SetMIDISysexPermission(bool value) {
   const std::vector<WebTestProxyBase*>& windowList =
       test_interfaces_->windowList();
   for (unsigned i = 0; i < windowList.size(); ++i)
-    windowList.at(i)->midiClientMock()->setSysexPermission(value);
+    windowList.at(i)->GetMIDIClientMock()->setSysexPermission(value);
 }
 
 void TestRunner::GrantWebNotificationPermission(const std::string& origin,
                                                 bool permission_granted) {
   notification_presenter_->GrantPermission(origin, permission_granted);
 }
 
 bool TestRunner::SimulateWebNotificationClick(const std::string& value) {
   return notification_presenter_->SimulateClick(value);
 }
 
 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript,
                                                 double confidence) {
-  proxy_->speechRecognizerMock()->addMockResult(
+  proxy_->GetSpeechRecognizerMock()->addMockResult(
       WebString::fromUTF8(transcript), confidence);
 }
 
 void TestRunner::SetMockSpeechRecognitionError(const std::string& error,
                                                const std::string& message) {
-  proxy_->speechRecognizerMock()->setError(WebString::fromUTF8(error),
+  proxy_->GetSpeechRecognizerMock()->setError(WebString::fromUTF8(error),
                                            WebString::fromUTF8(message));
 }
 
 bool TestRunner::WasMockSpeechRecognitionAborted() {
-  return proxy_->speechRecognizerMock()->wasAborted();
+  return proxy_->GetSpeechRecognizerMock()->wasAborted();
 }
 
 void TestRunner::AddWebPageOverlay() {
   if (web_view_ && !page_overlay_) {
     page_overlay_ = new TestPageOverlay(web_view_);
     web_view_->addPageOverlay(page_overlay_, 0);
   }
 }
 
 void TestRunner::RemoveWebPageOverlay() {
   if (web_view_ && page_overlay_) {
     web_view_->removePageOverlay(page_overlay_);
     delete page_overlay_;
     page_overlay_ = NULL;
   }
 }
 
 void TestRunner::DisplayAsync() {
-  proxy_->displayAsyncThen(base::Closure());
+  proxy_->DisplayAsyncThen(base::Closure());
 }
 
 void TestRunner::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
-  proxy_->displayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
+  proxy_->DisplayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
                                       base::Unretained(this),
                                       base::Passed(&task)));
 }
 
 void TestRunner::LocationChangeDone() {
   web_history_item_count_ = delegate_->navigationEntryCount();
 
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
@@ skipping 38 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content