Move //components/test_runner back into //content/shell

content/shell/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 "components/test_runner/test_plugin.h"
+#include "content/shell/test_runner/test_plugin.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/stringprintf.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/resources/shared_bitmap_manager.h"
-#include "components/test_runner/web_test_delegate.h"
+#include "content/shell/test_runner/web_test_delegate.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebCompositorSupport.h"
 #include "third_party/WebKit/public/platform/WebGestureEvent.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3DProvider.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebMouseEvent.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebTouchEvent.h"
 #include "third_party/WebKit/public/platform/WebTouchPoint.h"
@@ skipping 34 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",
-                                              points[i].position.x,
-                                              points[i].position.y,
-                                              PointState(points[i].state)));
+    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()) ||
@@ skipping 65 matching lines @@
     else if (attribute_name == "supports-keyboard-focus")
       supports_keyboard_focus_ = ParseBoolean(attribute_value);
     else if (attribute_name == "print-user-gesture-status")
       print_user_gesture_status_ = ParseBoolean(attribute_value);
   }
   if (can_create_without_renderer_)
     delegate_->PrintMessage(
         std::string("TestPlugin: canCreateWithoutRenderer\n"));
 }
 
-TestPlugin::~TestPlugin() {
-}
+TestPlugin::~TestPlugin() {}
 
 bool TestPlugin::initialize(blink::WebPluginContainer* container) {
   DCHECK(container);
   DCHECK_EQ(this, container->plugin());
 
   container_ = container;
 
   blink::Platform::ContextAttributes attrs;
   attrs.webGLVersion = 1;  // We are creating a context through the WebGL APIs.
   blink::WebURL url = container->document().url();
@@ skipping 134 matching lines @@
     *release_callback = cc::SingleReleaseCallback::Create(
         base::Bind(&ReleaseSharedMemory, base::Passed(&shared_bitmap_)));
   }
   mailbox_changed_ = false;
   return true;
 }
 
 TestPlugin::Primitive TestPlugin::ParsePrimitive(
     const blink::WebString& string) {
   const CR_DEFINE_STATIC_LOCAL(blink::WebString, kPrimitiveNone, ("none"));
-  const CR_DEFINE_STATIC_LOCAL(
-      blink::WebString, kPrimitiveTriangle, ("triangle"));
+  const CR_DEFINE_STATIC_LOCAL(blink::WebString, kPrimitiveTriangle,
+                               ("triangle"));
 
   Primitive primitive = PrimitiveNone;
   if (string == kPrimitiveNone)
     primitive = PrimitiveNone;
   else if (string == kPrimitiveTriangle)
     primitive = PrimitiveTriangle;
   else
     NOTREACHED();
   return primitive;
 }
@@ skipping 159 matching lines @@
   gl_->EnableVertexAttribArray(scene_.position_location);
   gl_->VertexAttribPointer(scene_.position_location, 3, GL_FLOAT, GL_FALSE, 0,
                            nullptr);
   gl_->DrawArrays(GL_TRIANGLES, 0, 3);
 }
 
 GLuint TestPlugin::LoadShader(GLenum type, const std::string& source) {
   GLuint shader = gl_->CreateShader(type);
   if (shader) {
     const GLchar* shader_data = source.data();
-    GLint shader_length = strlen(shader_data); //source.length();
+    GLint shader_length = strlen(shader_data);  // source.length();
     gl_->ShaderSource(shader, 1, &shader_data, &shader_length);
     gl_->CompileShader(shader);
 
     int compiled = 0;
     gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
     if (!compiled) {
       gl_->DeleteShader(shader);
       shader = 0;
     }
   }
@@ skipping 74 matching lines @@
   return false;
 }
 
 TestPlugin* TestPlugin::create(blink::WebFrame* frame,
                                const blink::WebPluginParams& params,
                                WebTestDelegate* delegate) {
   return new TestPlugin(frame, params, delegate);
 }
 
 const blink::WebString& TestPlugin::MimeType() {
-  const CR_DEFINE_STATIC_LOCAL(
-      blink::WebString, kMimeType, ("application/x-webkit-test-webplugin"));
+  const CR_DEFINE_STATIC_LOCAL(blink::WebString, kMimeType,
+                               ("application/x-webkit-test-webplugin"));
   return kMimeType;
 }
 
 const blink::WebString& TestPlugin::CanCreateWithoutRendererMimeType() {
   const CR_DEFINE_STATIC_LOCAL(
-      blink::WebString,
-      kCanCreateWithoutRendererMimeType,
+      blink::WebString, kCanCreateWithoutRendererMimeType,
       ("application/x-webkit-test-webplugin-can-create-without-renderer"));
   return kCanCreateWithoutRendererMimeType;
 }
 
 const blink::WebString& TestPlugin::PluginPersistsMimeType() {
   const CR_DEFINE_STATIC_LOCAL(
-      blink::WebString,
-      kPluginPersistsMimeType,
+      blink::WebString, kPluginPersistsMimeType,
       ("application/x-webkit-test-webplugin-persistent"));
   return kPluginPersistsMimeType;
 }
 
 bool TestPlugin::IsSupportedMimeType(const blink::WebString& mime_type) {
   return mime_type == TestPlugin::MimeType() ||
          mime_type == PluginPersistsMimeType() ||
          mime_type == CanCreateWithoutRendererMimeType();
 }
 
 }  // namespace test_runner