Update WebTask in chromium c++ 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"
@@ skipping 53 matching lines @@
   v8_str->WriteUtf8(chars.get(), length);
   return WebString::fromUTF8(chars.get());
 }
 
 class HostMethodTask : public WebMethodTask<TestRunner> {
  public:
   typedef void (TestRunner::*CallbackMethodType)();
   HostMethodTask(TestRunner* object, CallbackMethodType callback)
       : WebMethodTask<TestRunner>(object), callback_(callback) {}
 
-  virtual void runIfValid() OVERRIDE {
-    (m_object->*callback_)();
-  }
+  virtual void RunIfValid() OVERRIDE { (object_->*callback_)(); }
 
  private:
   CallbackMethodType callback_;
 };
 
 }  // namespace
 
 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
  public:
   InvokeCallbackTask(TestRunner* object, v8::Handle<v8::Function> callback)
       : WebMethodTask<TestRunner>(object),
         callback_(blink::mainThreadIsolate(), callback),
         argc_(0) {}
 
-  virtual void runIfValid() OVERRIDE {
+  virtual void RunIfValid() OVERRIDE {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     v8::HandleScope handle_scope(isolate);
-    WebFrame* frame = m_object->web_view_->mainFrame();
+    WebFrame* frame = object_->web_view_->mainFrame();
 
     v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
     if (context.IsEmpty())
       return;
 
     v8::Context::Scope context_scope(context);
 
     scoped_ptr<v8::Handle<v8::Value>[]> local_argv;
     if (argc_) {
         local_argv.reset(new v8::Handle<v8::Value>[argc_]);
@@ skipping 1380 matching lines @@
     delete queue_.front();
     queue_.pop_front();
     if (startedLoad)
       return;
   }
 
   if (!controller_->wait_until_done_ && !controller_->topLoadingFrame())
     controller_->delegate_->testFinished();
 }
 
-void TestRunner::WorkQueue::WorkQueueTask::runIfValid() {
-  m_object->ProcessWork();
+void TestRunner::WorkQueue::WorkQueueTask::RunIfValid() {
+  object_->ProcessWork();
 }
 
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
       disable_notify_done_(false),
       web_history_item_count_(0),
       intercept_post_message_(false),
       test_interfaces_(interfaces),
@@ skipping 110 matching lines @@
   web_history_item_count_ = 0;
   intercept_post_message_ = false;
 
   web_permissions_->Reset();
 
   notification_presenter_->Reset();
   use_mock_theme_ = true;
   pointer_locked_ = false;
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 
-  task_list_.revokeAll();
+  task_list_.RevokeAll();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
     delegate_->closeRemainingWindows();
   else
     close_remaining_windows_ = true;
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
@@ skipping 261 matching lines @@
 
  private:
   int distance_;
 };
 
 void TestRunner::NotifyDone() {
   if (disable_notify_done_)
     return;
 
   // Test didn't timeout. Kill the timeout timer.
-  task_list_.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 976 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content