Introduce components/display_compositor

components/display_compositor/buffer_queue.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/browser/compositor/buffer_queue.h"
+#include "components/display_compositor/buffer_queue.h"
 
 #include "base/containers/adapters.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "cc/output/context_provider.h"
-#include "content/browser/compositor/gl_helper.h"
+#include "components/display_compositor/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/skia_util.h"
 
-namespace content {
+namespace display_compositor {
 
 BufferQueue::BufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
                          unsigned int texture_target,
                          unsigned int internalformat,
                          GLHelper* gl_helper,
                          gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                          int surface_id)
     : context_provider_(context_provider),
       fbo_(0),
       allocated_count_(0),
@@ skipping 26 matching lines @@
   if (current_surface_) {
     gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                              texture_target_, current_surface_->texture, 0);
   }
 }
 
 void BufferQueue::CopyBufferDamage(int texture,
                                    int source_texture,
                                    const gfx::Rect& new_damage,
                                    const gfx::Rect& old_damage) {
-  gl_helper_->CopySubBufferDamage(
-      texture_target_, texture, source_texture,
-      SkRegion(gfx::RectToSkIRect(new_damage)),
-      SkRegion(gfx::RectToSkIRect(old_damage)));
+  gl_helper_->CopySubBufferDamage(texture_target_, texture, source_texture,
+                                  SkRegion(gfx::RectToSkIRect(new_damage)),
+                                  SkRegion(gfx::RectToSkIRect(old_damage)));
 }
 
 void BufferQueue::UpdateBufferDamage(const gfx::Rect& damage) {
   if (displayed_surface_)
     displayed_surface_->damage.Union(damage);
   for (auto& surface : available_surfaces_)
     surface->damage.Union(damage);
   for (auto& surface : in_flight_surfaces_) {
     if (surface)
       surface->damage.Union(damage);
@@ skipping 26 matching lines @@
   UpdateBufferDamage(damage);
   in_flight_surfaces_.push_back(std::move(current_surface_));
   // Some things reset the framebuffer (CopySubBufferDamage, some GLRenderer
   // paths), so ensure we restore it here.
   context_provider_->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
 }
 
 void BufferQueue::Reshape(const gfx::Size& size, float scale_factor) {
   if (size == size_)
     return;
+#if !defined(OS_MACOSX)
   // TODO(ccameron): This assert is being hit on Mac try jobs. Determine if that
   // is cause for concern or if it is benign.
   // http://crbug.com/524624
-#if !defined(OS_MACOSX)
   DCHECK(!current_surface_);
 #endif
   size_ = size;
 
   // TODO: add stencil buffer when needed.
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
   gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                            texture_target_, 0, 0);
 
@@ skipping 91 matching lines @@
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           size_, gpu::DefaultBufferFormatForImageFormat(internal_format_),
           gfx::BufferUsage::SCANOUT, surface_id_));
   if (!buffer.get()) {
     gl->DeleteTextures(1, &texture);
     DLOG(ERROR) << "Failed to allocate GPU memory buffer";
     return nullptr;
   }
 
-  unsigned int id = gl->CreateImageCHROMIUM(
-      buffer->AsClientBuffer(), size_.width(), size_.height(),
-      internal_format_);
+  unsigned int id =
+      gl->CreateImageCHROMIUM(buffer->AsClientBuffer(), size_.width(),
+                              size_.height(), internal_format_);
   if (!id) {
     LOG(ERROR) << "Failed to allocate backing image surface";
     gl->DeleteTextures(1, &texture);
     return nullptr;
   }
 
   allocated_count_++;
   gl->BindTexture(texture_target_, texture);
   gl->BindTexImage2DCHROMIUM(texture_target_, id);
   return base::WrapUnique(new AllocatedSurface(this, std::move(buffer), texture,
                                                id, gfx::Rect(size_)));
 }
 
 BufferQueue::AllocatedSurface::AllocatedSurface(
     BufferQueue* buffer_queue,
     std::unique_ptr<gfx::GpuMemoryBuffer> buffer,
     unsigned int texture,
     unsigned int image,
     const gfx::Rect& rect)
     : buffer_queue(buffer_queue),
       buffer(buffer.release()),
       texture(texture),
       image(image),
       damage(rect) {}
 
 BufferQueue::AllocatedSurface::~AllocatedSurface() {
   buffer_queue->FreeSurfaceResources(this);
 }
 
-}  // namespace content
+}  // namespace display_compositor