Abstract class WebTestDelegate to chromium c++ style.

content/shell/renderer/test_runner/test_plugin.cc

 // Copyright 2013 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_plugin.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/renderer/render_thread.h"
-#include "content/shell/renderer/test_runner/WebTestDelegate.h"
+#include "content/shell/renderer/test_runner/web_test_delegate.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebCompositorSupport.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
@@ skipping 55 matching lines @@
       return "Cancelled";
     default:
       return "Unknown";
   }
 }
 
 void PrintTouchList(WebTestDelegate* delegate,
                     const blink::WebTouchPoint* points,
                     int length) {
   for (int i = 0; i < length; ++i) {
-    delegate->printMessage(base::StringPrintf("* %.2f, %.2f: %s\n",
+    delegate->PrintMessage(base::StringPrintf("* %.2f, %.2f: %s\n",
                                               points[i].position.x,
                                               points[i].position.y,
                                               PointState(points[i].state)));
   }
 }
 
 void PrintEventDetails(WebTestDelegate* delegate,
                        const blink::WebInputEvent& event) {
   if (blink::WebInputEvent::isTouchEventType(event.type)) {
     const blink::WebTouchEvent& touch =
         static_cast<const blink::WebTouchEvent&>(event);
     PrintTouchList(delegate, touch.touches, touch.touchesLength);
   } else if (blink::WebInputEvent::isMouseEventType(event.type) ||
              event.type == blink::WebInputEvent::MouseWheel) {
     const blink::WebMouseEvent& mouse =
         static_cast<const blink::WebMouseEvent&>(event);
-    delegate->printMessage(base::StringPrintf("* %d, %d\n", mouse.x, mouse.y));
+    delegate->PrintMessage(base::StringPrintf("* %d, %d\n", mouse.x, mouse.y));
   } else if (blink::WebInputEvent::isGestureEventType(event.type)) {
     const blink::WebGestureEvent& gesture =
         static_cast<const blink::WebGestureEvent&>(event);
-    delegate->printMessage(
+    delegate->PrintMessage(
         base::StringPrintf("* %d, %d\n", gesture.x, gesture.y));
   }
 }
 
 blink::WebPluginContainer::TouchEventRequestType ParseTouchEventRequestType(
     const blink::WebString& string) {
   if (string == blink::WebString::fromUTF8("raw"))
     return blink::WebPluginContainer::TouchEventRequestTypeRaw;
   if (string == blink::WebString::fromUTF8("synthetic"))
     return blink::WebPluginContainer::TouchEventRequestTypeSynthesizedMouse;
@@ skipping 65 matching lines @@
     else if (attribute_name == kAttributeReRequestTouchEvents)
       re_request_touch_events_ = ParseBoolean(attribute_value);
     else if (attribute_name == kAttributePrintEventDetails)
       print_event_details_ = ParseBoolean(attribute_value);
     else if (attribute_name == kAttributeCanProcessDrag)
       can_process_drag_ = ParseBoolean(attribute_value);
     else if (attribute_name == kAttributePrintUserGestureStatus)
       print_user_gesture_status_ = ParseBoolean(attribute_value);
   }
   if (can_create_without_renderer_)
-    delegate_->printMessage(
+    delegate_->PrintMessage(
         std::string("TestPlugin: canCreateWithoutRenderer\n"));
 }
 
 TestPlugin::~TestPlugin() {
 }
 
 bool TestPlugin::initialize(blink::WebPluginContainer* container) {
   blink::WebGraphicsContext3D::Attributes attrs;
   context_ =
       blink::Platform::current()->createOffscreenGraphicsContext3D(attrs);
@@ skipping 467 matching lines @@
       event_name = "TouchMove";
       break;
     case blink::WebInputEvent::TouchEnd:
       event_name = "TouchEnd";
       break;
     case blink::WebInputEvent::TouchCancel:
       event_name = "TouchCancel";
       break;
   }
 
-  delegate_->printMessage(std::string("Plugin received event: ") +
+  delegate_->PrintMessage(std::string("Plugin received event: ") +
                           (event_name ? event_name : "unknown") + "\n");
   if (print_event_details_)
     PrintEventDetails(delegate_, event);
   if (print_user_gesture_status_)
-    delegate_->printMessage(
+    delegate_->PrintMessage(
         std::string("* ") +
         (blink::WebUserGestureIndicator::isProcessingUserGesture() ? ""
                                                                    : "not ") +
         "handling user gesture\n");
   if (is_persistent_)
-    delegate_->printMessage(std::string("TestPlugin: isPersistent\n"));
+    delegate_->PrintMessage(std::string("TestPlugin: isPersistent\n"));
   return false;
 }
 
 bool TestPlugin::handleDragStatusUpdate(
     blink::WebDragStatus drag_status,
     const blink::WebDragData& data,
     blink::WebDragOperationsMask mask,
     const blink::WebPoint& position,
     const blink::WebPoint& screen_position) {
   const char* drag_status_name = 0;
   switch (drag_status) {
     case blink::WebDragStatusEnter:
       drag_status_name = "DragEnter";
       break;
     case blink::WebDragStatusOver:
       drag_status_name = "DragOver";
       break;
     case blink::WebDragStatusLeave:
       drag_status_name = "DragLeave";
       break;
     case blink::WebDragStatusDrop:
       drag_status_name = "DragDrop";
       break;
     case blink::WebDragStatusUnknown:
       NOTREACHED();
   }
-  delegate_->printMessage(std::string("Plugin received event: ") +
+  delegate_->PrintMessage(std::string("Plugin received event: ") +
                           drag_status_name + "\n");
   return false;
 }
 
 TestPlugin* TestPlugin::create(blink::WebFrame* frame,
                                const blink::WebPluginParams& params,
                                WebTestDelegate* delegate) {
   return new TestPlugin(frame, params, delegate);
 }
 
@@ skipping 19 matching lines @@
   return kPluginPersistsMimeType;
 }
 
 bool TestPlugin::IsSupportedMimeType(const blink::WebString& mime_type) {
   return mime_type == TestPlugin::MimeType() ||
          mime_type == PluginPersistsMimeType() ||
          mime_type == CanCreateWithoutRendererMimeType();
 }
 
 }  // namespace content