media/gpu: restore some of the reformatting done during migration to media/gpu.

media/gpu/rendering_helper.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 "media/gpu/rendering_helper.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 193 matching lines @@
   Clear();
 }
 
 RenderingHelper::~RenderingHelper() {
   CHECK_EQ(videos_.size(), 0U) << "Must call UnInitialize before dtor.";
   Clear();
 }
 
 void RenderingHelper::Setup() {
 #if defined(OS_WIN)
-  window_ = CreateWindowEx(
-      0, L"Static", L"VideoDecodeAcceleratorTest",
-      WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, GetSystemMetrics(SM_CXSCREEN),
-      GetSystemMetrics(SM_CYSCREEN), NULL, NULL, NULL, NULL);
+  window_ = CreateWindowEx(0,
+                           L"Static",
+                           L"VideoDecodeAcceleratorTest",
+                           WS_OVERLAPPEDWINDOW | WS_VISIBLE,
+                           0, 0,
+                           GetSystemMetrics(SM_CXSCREEN),
+                           GetSystemMetrics(SM_CYSCREEN),
+                           NULL, NULL, NULL, NULL);
 #elif defined(USE_X11)
   Display* display = gfx::GetXDisplay();
   Screen* screen = DefaultScreenOfDisplay(display);
 
   CHECK(display);
 
   XSetWindowAttributes window_attributes;
   memset(&window_attributes, 0, sizeof(window_attributes));
   window_attributes.background_pixel =
       BlackPixel(display, DefaultScreen(display));
   window_attributes.override_redirect = true;
   int depth = DefaultDepth(display, DefaultScreen(display));
 
-  window_ = XCreateWindow(
-      display, DefaultRootWindow(display), 0, 0, XWidthOfScreen(screen),
-      XHeightOfScreen(screen), 0 /* border width */, depth,
-      CopyFromParent /* class */, CopyFromParent /* visual */,
-      (CWBackPixel | CWOverrideRedirect), &window_attributes);
+  window_ = XCreateWindow(display,
+                          DefaultRootWindow(display),
+                          0, 0,
+                          XWidthOfScreen(screen),
+                          XHeightOfScreen(screen),
+                          0 /* border width */,
+                          depth,
+                          CopyFromParent /* class */,
+                          CopyFromParent /* visual */,
+                          (CWBackPixel | CWOverrideRedirect),
+                          &window_attributes);
   XStoreName(display, window_, "VideoDecodeAcceleratorTest");
   XSelectInput(display, window_, ExposureMask);
   XMapWindow(display, window_);
 #elif defined(USE_OZONE)
   base::MessageLoop::ScopedNestableTaskAllower nest_loop(
       base::MessageLoop::current());
   base::RunLoop wait_window_resize;
 
   platform_window_delegate_.reset(new RenderingHelper::StubOzoneDelegate());
   window_ = platform_window_delegate_->accelerated_widget();
@@ skipping 104 matching lines @@
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
     CHECK_GE(max_texture_size, params.thumbnails_page_size.width());
     CHECK_GE(max_texture_size, params.thumbnails_page_size.height());
 
     thumbnails_fbo_size_ = params.thumbnails_page_size;
     thumbnail_size_ = params.thumbnail_size;
 
     glGenFramebuffersEXT(1, &thumbnails_fbo_id_);
     glGenTextures(1, &thumbnails_texture_id_);
     glBindTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, thumbnails_fbo_size_.width(),
-                 thumbnails_fbo_size_.height(), 0, GL_RGB,
-                 GL_UNSIGNED_SHORT_5_6_5, NULL);
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 GL_RGB,
+                 thumbnails_fbo_size_.width(), thumbnails_fbo_size_.height(),
+                 0,
+                 GL_RGB,
+                 GL_UNSIGNED_SHORT_5_6_5,
+                 NULL);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glBindTexture(GL_TEXTURE_2D, 0);
 
     glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D, thumbnails_texture_id_, 0);
 
@@ skipping 38 matching lines @@
       "#endif\n"
       "void main() {\n"
       "  vec4 color = texture2D(tex, interp_tc);\n"
       "#ifdef GL_OES_EGL_image_external\n"
       "  color += texture2D(tex_external, interp_tc);\n"
       "#endif\n"
       "  gl_FragColor = color;\n"
       "}\n";
 #else
   static const char kFragmentShader[] =
-      STRINGIZE(varying vec2 interp_tc; uniform sampler2D tex;
-                void main() { gl_FragColor = texture2D(tex, interp_tc); });
+      STRINGIZE(varying vec2 interp_tc;
+                uniform sampler2D tex;
+                void main() {
+                  gl_FragColor = texture2D(tex, interp_tc);
+                });
 #endif
   program_ = glCreateProgram();
   CreateShader(program_, GL_VERTEX_SHADER, kVertexShader,
                arraysize(kVertexShader));
   CreateShader(program_, GL_FRAGMENT_SHADER, kFragmentShader,
                arraysize(kFragmentShader));
   glLinkProgram(program_);
   int result = GL_FALSE;
   glGetProgramiv(program_, GL_LINK_STATUS, &result);
   if (!result) {
@@ skipping 50 matching lines @@
 
 // The rendering for the first few frames is slow (e.g., 100ms on Peach Pit).
 // This affects the numbers measured in the performance test. We try to render
 // several frames here to warm up the rendering.
 void RenderingHelper::WarmUpRendering(int warm_up_iterations) {
   unsigned int texture_id;
   std::unique_ptr<GLubyte[]> emptyData(
       new GLubyte[screen_size_.GetArea() * 2]());
   glGenTextures(1, &texture_id);
   glBindTexture(GL_TEXTURE_2D, texture_id);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screen_size_.width(),
-               screen_size_.height(), 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
+  glTexImage2D(GL_TEXTURE_2D,
+               0,
+               GL_RGB,
+               screen_size_.width(), screen_size_.height(),
+               0,
+               GL_RGB,
+               GL_UNSIGNED_SHORT_5_6_5,
                emptyData.get());
   for (int i = 0; i < warm_up_iterations; ++i) {
     RenderTexture(GL_TEXTURE_2D, texture_id);
 
     // Need to allow nestable tasks since WarmUpRendering() is called from
     // within another task on the renderer thread.
     base::MessageLoop::ScopedNestableTaskAllower allow(
         base::MessageLoop::current());
     base::RunLoop wait_for_swap_ack;
     gl_surface_->SwapBuffersAsync(
@@ skipping 28 matching lines @@
   if (base::MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
                    texture_target, texture_id, size, done));
     return;
   }
   glGenTextures(1, texture_id);
   glBindTexture(texture_target, *texture_id);
   if (texture_target == GL_TEXTURE_2D) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
-                 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 GL_RGBA,
+                 size.width(), size.height(),
+                 0,
+                 GL_RGBA,
+                 GL_UNSIGNED_BYTE,
+                 NULL);
   }
   glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   // OpenGLES2.0.25 section 3.8.2 requires CLAMP_TO_EDGE for NPOT textures.
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   done->Signal();
 }
 
@@ skipping 94 matching lines @@
                                          bool* alpha_solid,
                                          base::WaitableEvent* done) {
   CHECK(render_as_thumbnails_);
 
   const size_t num_pixels = thumbnails_fbo_size_.GetArea();
   std::vector<unsigned char> rgba;
   rgba.resize(num_pixels * 4);
   glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   // We can only count on GL_RGBA/GL_UNSIGNED_BYTE support.
-  glReadPixels(0, 0, thumbnails_fbo_size_.width(),
-               thumbnails_fbo_size_.height(), GL_RGBA, GL_UNSIGNED_BYTE,
+  glReadPixels(0, 0,
+               thumbnails_fbo_size_.width(), thumbnails_fbo_size_.height(),
+               GL_RGBA,
+               GL_UNSIGNED_BYTE,
                &rgba[0]);
   glBindFramebufferEXT(GL_FRAMEBUFFER,
                        gl_surface_->GetBackingFrameBufferObject());
   rgb->resize(num_pixels * 3);
   // Drop the alpha channel, but check as we go that it is all 0xff.
   bool solid = true;
   unsigned char* rgb_ptr = &((*rgb)[0]);
   unsigned char* rgba_ptr = &rgba[0];
   for (size_t i = 0; i < num_pixels; ++i) {
     *rgb_ptr++ = *rgba_ptr++;
@@ skipping 169 matching lines @@
   // When the rendering falls behind, drops frames.
   while (scheduled_render_time_ < target) {
     scheduled_render_time_ += frame_duration_;
     DropOneFrameForAllVideos();
   }
 
   message_loop_->PostDelayedTask(FROM_HERE, render_task_.callback(),
                                  target - now);
 }
 }  // namespace media