Test X11 header pollution

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 "content/common/gpu/media/rendering_helper.h"
+#include "media/gpu/rendering_helper.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 49 matching lines @@
   if (!result) {
     char log[4096];
     glGetShaderInfoLog(shader, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glAttachShader(program, shader);
   glDeleteShader(shader);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
-namespace content {
+namespace media {
 namespace {
 
 void WaitForSwapAck(const base::Closure& callback, gfx::SwapResult result) {
   callback.Run();
 }
 
 }  // namespace
 
 #if defined(USE_OZONE)
 
@@ skipping 34 matching lines @@
 
   void OnDamageRect(const gfx::Rect& damaged_region) override {}
 
   void DispatchEvent(ui::Event* event) override {}
 
   void OnCloseRequest() override {}
   void OnClosed() override {}
 
   void OnWindowStateChanged(ui::PlatformWindowState new_state) override {}
 
-  void OnLostCapture() override {};
+  void OnLostCapture() override{};
 
   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
                                     float device_pixel_ratio) override {
     accelerated_widget_ = widget;
   }
 
-  void OnAcceleratedWidgetDestroyed() override {
-    NOTREACHED();
-  }
+  void OnAcceleratedWidgetDestroyed() override { NOTREACHED(); }
 
-  void OnActivationChanged(bool active) override {};
+  void OnActivationChanged(bool active) override{};
 
   gfx::AcceleratedWidget accelerated_widget() const {
     return accelerated_widget_;
   }
 
   gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
 
   ui::PlatformWindow* platform_window() const { return platform_window_.get(); }
 
  private:
   std::unique_ptr<ui::PlatformWindow> platform_window_;
   gfx::AcceleratedWidget accelerated_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(StubOzoneDelegate);
 };
 
 #endif  // defined(USE_OZONE)
 
 RenderingHelperParams::RenderingHelperParams()
-    : rendering_fps(0), warm_up_iterations(0), render_as_thumbnails(false) {
-}
+    : rendering_fps(0), warm_up_iterations(0), render_as_thumbnails(false) {}
 
 RenderingHelperParams::RenderingHelperParams(
     const RenderingHelperParams& other) = default;
 
 RenderingHelperParams::~RenderingHelperParams() {}
 
 VideoFrameTexture::VideoFrameTexture(uint32_t texture_target,
                                      uint32_t texture_id,
                                      const base::Closure& no_longer_needed_cb)
     : texture_target_(texture_target),
       texture_id_(texture_id),
       no_longer_needed_cb_(no_longer_needed_cb) {
   DCHECK(!no_longer_needed_cb_.is_null());
 }
 
 VideoFrameTexture::~VideoFrameTexture() {
   base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 RenderingHelper::RenderedVideo::RenderedVideo()
-    : is_flushing(false), frames_to_drop(0) {
-}
+    : is_flushing(false), frames_to_drop(0) {}
 
 RenderingHelper::RenderedVideo::RenderedVideo(const RenderedVideo& other) =
     default;
 
-RenderingHelper::RenderedVideo::~RenderedVideo() {
-}
+RenderingHelper::RenderedVideo::~RenderedVideo() {}
 
 // static
 void RenderingHelper::InitializeOneOff(base::WaitableEvent* done) {
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 #if GL_VARIANT_GLX
   cmd_line->AppendSwitchASCII(switches::kUseGL,
                               gfx::kGLImplementationDesktopName);
 #else
   cmd_line->AppendSwitchASCII(switches::kUseGL, gfx::kGLImplementationEGLName);
 #endif
 
   if (!gfx::GLSurface::InitializeOneOff())
     LOG(FATAL) << "Could not initialize GL";
   done->Signal();
 }
 
 RenderingHelper::RenderingHelper() : ignore_vsync_(false) {
   window_ = gfx::kNullAcceleratedWidget;
   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 83 matching lines @@
 
   render_as_thumbnails_ = params.render_as_thumbnails;
   message_loop_ = base::MessageLoop::current();
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
 #if defined(USE_OZONE)
   gl_surface_->Resize(platform_window_delegate_->GetSize(), 1.f, true);
 #endif  // defined(USE_OZONE)
   screen_size_ = gl_surface_->GetSize();
 
-  gl_context_ = gfx::GLContext::CreateGLContext(
-      NULL, gl_surface_.get(), gfx::PreferIntegratedGpu);
+  gl_context_ = gfx::GLContext::CreateGLContext(NULL, gl_surface_.get(),
+                                                gfx::PreferIntegratedGpu);
   CHECK(gl_context_->MakeCurrent(gl_surface_.get()));
 
   CHECK_GT(params.window_sizes.size(), 0U);
   videos_.resize(params.window_sizes.size());
   LayoutRenderingAreas(params.window_sizes);
 
   if (render_as_thumbnails_) {
     CHECK_EQ(videos_.size(), 1U);
 
     GLint max_texture_size;
     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);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, thumbnails_texture_id_, 0);
 
     GLenum fb_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
     CHECK(fb_status == GL_FRAMEBUFFER_COMPLETE) << fb_status;
     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
     glBindFramebufferEXT(GL_FRAMEBUFFER,
                          gl_surface_->GetBackingFrameBufferObject());
   }
 
   // These vertices and texture coords. map (0,0) in the texture to the
   // bottom left of the viewport.  Since we get the video frames with the
   // the top left at (0,0) we need to flip the texture y coordinate
   // in the vertex shader for this to be rendered the right way up.
   // In the case of thumbnail rendering we use the same vertex shader
   // to render the FBO the screen, where we do not want this flipping.
-  static const float kVertices[] =
-      { -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f, -1.f, };
-  static const float kTextureCoords[] = { 0, 1, 0, 0, 1, 1, 1, 0, };
-  static const char kVertexShader[] = STRINGIZE(
-      varying vec2 interp_tc;
-      attribute vec4 in_pos;
-      attribute vec2 in_tc;
-      uniform bool tex_flip;
-      void main() {
-        if (tex_flip)
-          interp_tc = vec2(in_tc.x, 1.0 - in_tc.y);
-        else
-          interp_tc = in_tc;
-        gl_Position = in_pos;
-      });
+  static const float kVertices[] = {
+      -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f, -1.f,
+  };
+  static const float kTextureCoords[] = {
+      0, 1, 0, 0, 1, 1, 1, 0,
+  };
+  static const char kVertexShader[] =
+      STRINGIZE(varying vec2 interp_tc; attribute vec4 in_pos;
+                attribute vec2 in_tc; uniform bool tex_flip; void main() {
+                  if (tex_flip)
+                    interp_tc = vec2(in_tc.x, 1.0 - in_tc.y);
+                  else
+                    interp_tc = in_tc;
+                  gl_Position = in_pos;
+                });
 
 #if GL_VARIANT_EGL
   static const char kFragmentShader[] =
       "#extension GL_OES_EGL_image_external : enable\n"
       "precision mediump float;\n"
       "varying vec2 interp_tc;\n"
       "uniform sampler2D tex;\n"
       "#ifdef GL_OES_EGL_image_external\n"
       "uniform samplerExternalOES tex_external;\n"
       "#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);
-      });
+  static const char kFragmentShader[] =
+      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,
+  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) {
     char log[4096];
     glGetShaderInfoLog(program_, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glUseProgram(program_);
@@ skipping 45 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 19 matching lines @@
 
   Clear();
   done->Signal();
 }
 
 void RenderingHelper::CreateTexture(uint32_t texture_target,
                                     uint32_t* texture_id,
                                     const gfx::Size& size,
                                     base::WaitableEvent* done) {
   if (base::MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE,
-                            base::Bind(&RenderingHelper::CreateTexture,
-                                       base::Unretained(this),
-                                       texture_target,
-                                       texture_id,
-                                       size,
-                                       done));
+    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 30 matching lines @@
 #if defined(USE_OZONE)
   // Ozone surfaceless renders flipped from normal GL, so there's no need to
   // do an extra flip.
   tex_flip = 0;
 #endif  // defined(USE_OZONE)
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), tex_flip);
 
   // Frames that will be returned to the client (via the no_longer_needed_cb)
   // after this vector falls out of scope at the end of this method. We need
   // to keep references to them until after SwapBuffers() call below.
-  std::vector<scoped_refptr<VideoFrameTexture> > frames_to_be_returned;
+  std::vector<scoped_refptr<VideoFrameTexture>> frames_to_be_returned;
   bool need_swap_buffer = false;
   if (render_as_thumbnails_) {
     // In render_as_thumbnails_ mode, we render the FBO content on the
     // screen instead of the decoded textures.
     GLSetViewPort(videos_[0].render_area);
     RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
     need_swap_buffer = true;
   } else {
     for (RenderedVideo& video : videos_) {
       if (video.pending_frames.empty())
@@ skipping 12 matching lines @@
     }
   }
 
   base::Closure schedule_frame = base::Bind(
       &RenderingHelper::ScheduleNextRenderContent, base::Unretained(this));
   if (!need_swap_buffer) {
     schedule_frame.Run();
     return;
   }
 
-  gl_surface_->SwapBuffersAsync(
-          base::Bind(&WaitForSwapAck, schedule_frame));
+  gl_surface_->SwapBuffersAsync(base::Bind(&WaitForSwapAck, schedule_frame));
 }
 
 // Helper function for the LayoutRenderingAreas(). The |lengths| are the
 // heights(widths) of the rows(columns). It scales the elements in
 // |lengths| proportionally so that the sum of them equal to |total_length|.
 // It also outputs the coordinates of the rows(columns) to |offsets|.
 static void ScaleAndCalculateOffsets(std::vector<int>* lengths,
                                      std::vector<int>* offsets,
                                      int total_length) {
   int sum = std::accumulate(lengths->begin(), lengths->end(), 0);
@@ skipping 81 matching lines @@
     int64_t intervals = (target - vsync_timebase_) / vsync_interval_;
     target = vsync_timebase_ + intervals * vsync_interval_;
   }
 
   // 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);
+  message_loop_->PostDelayedTask(FROM_HERE, render_task_.callback(),
+                                 target - now);
 }
-}  // namespace content
+}  // namespace media