Move components/display_compositor to components/viz/display_compositor

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "cc/layers/surface_layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/latency_info_swap_promise.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
-#include "components/display_compositor/gl_helper.h"
+#include "components/viz/display_compositor/gl_helper.h"
 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
 #include "content/browser/android/composited_touch_handle_drawable.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/ime_adapter_android.h"
 #include "content/browser/android/overscroll_controller_android.h"
 #include "content/browser/android/selection_popup_controller.h"
 #include "content/browser/android/synchronous_compositor_host.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
@@ skipping 73 matching lines @@
   }
 };
 
 using base::android::ApplicationState;
 using base::android::ApplicationStatusListener;
 
 class GLHelperHolder {
  public:
   static GLHelperHolder* Create();
 
-  display_compositor::GLHelper* gl_helper() { return gl_helper_.get(); }
+  viz::GLHelper* gl_helper() { return gl_helper_.get(); }
   bool IsLost() {
     if (!gl_helper_)
       return true;
     return provider_->ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
   }
 
   void ReleaseIfPossible();
 
  private:
   GLHelperHolder();
   void Initialize();
   void OnContextLost();
   void OnApplicationStatusChanged(ApplicationState new_state);
 
   scoped_refptr<ui::ContextProviderCommandBuffer> provider_;
-  std::unique_ptr<display_compositor::GLHelper> gl_helper_;
+  std::unique_ptr<viz::GLHelper> gl_helper_;
 
   // Set to |false| if there are only stopped activities (or none).
   bool has_running_or_paused_activities_;
 
   std::unique_ptr<ApplicationStatusListener> app_status_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
 };
 
 GLHelperHolder::GLHelperHolder()
@@ skipping 53 matching lines @@
       attributes, nullptr,
       ui::command_buffer_metrics::BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
   if (!provider_->BindToCurrentThread())
     return;
   provider_->ContextGL()->TraceBeginCHROMIUM(
       "gpu_toplevel",
       base::StringPrintf("CmdBufferImageTransportFactory-%p", provider_.get())
           .c_str());
   provider_->SetLostContextCallback(
       base::Bind(&GLHelperHolder::OnContextLost, base::Unretained(this)));
-  gl_helper_.reset(new display_compositor::GLHelper(
-      provider_->ContextGL(), provider_->ContextSupport()));
+  gl_helper_.reset(
+      new viz::GLHelper(provider_->ContextGL(), provider_->ContextSupport()));
 
   // Unretained() is safe because |this| owns the following two callbacks.
   app_status_listener_.reset(new ApplicationStatusListener(base::Bind(
       &GLHelperHolder::OnApplicationStatusChanged, base::Unretained(this))));
 }
 
 void GLHelperHolder::ReleaseIfPossible() {
   if (!has_running_or_paused_activities_ && !g_pending_readback_lock) {
     gl_helper_.reset();
     provider_ = nullptr;
@@ skipping 28 matching lines @@
     delete g_readback_helper_holder;
     g_readback_helper_holder = nullptr;
   }
 
   if (!g_readback_helper_holder)
     g_readback_helper_holder = GLHelperHolder::Create();
 
   return g_readback_helper_holder;
 }
 
-display_compositor::GLHelper* GetPostReadbackGLHelper() {
+viz::GLHelper* GetPostReadbackGLHelper() {
   bool create_if_necessary = true;
   return GetPostReadbackGLHelperHolder(create_if_necessary)->gl_helper();
 }
 
 void ReleaseGLHelper() {
   bool create_if_necessary = false;
   GLHelperHolder* holder = GetPostReadbackGLHelperHolder(create_if_necessary);
 
   if (holder) {
     holder->ReleaseIfPossible();
   }
 }
 
 void CopyFromCompositingSurfaceFinished(
     const ReadbackRequestCallback& callback,
     std::unique_ptr<cc::SingleReleaseCallback> release_callback,
     std::unique_ptr<SkBitmap> bitmap,
     const base::TimeTicks& start_time,
     scoped_refptr<PendingReadbackLock> readback_lock,
     bool result) {
   TRACE_EVENT0(
       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
   gpu::SyncToken sync_token;
   if (result) {
-    display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper();
+    viz::GLHelper* gl_helper = GetPostReadbackGLHelper();
     if (gl_helper)
       gl_helper->GenerateSyncToken(&sync_token);
   }
 
   // PostTask() to make sure the |readback_lock| is released. Also do this
   // synchronous GPU operation in a clean callstack.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&ReleaseGLHelper));
 
   const bool lost_resource = !sync_token.HasData();
@@ skipping 48 matching lines @@
   TRACE_EVENT0("cc",
                "RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult");
   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
     return;
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
   result->TakeTexture(&texture_mailbox, &release_callback);
   DCHECK(texture_mailbox.IsTexture());
   if (!texture_mailbox.IsTexture())
     return;
-  display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper();
+  viz::GLHelper* gl_helper = GetPostReadbackGLHelper();
   if (!gl_helper)
     return;
   if (!gl_helper->IsReadbackConfigSupported(color_type))
     color_type = kRGBA_8888_SkColorType;
 
   gfx::Size output_size_in_pixel;
   if (dst_size_in_pixel.IsEmpty())
     output_size_in_pixel = result->size();
   else
     output_size_in_pixel = dst_size_in_pixel;
@@ skipping 11 matching lines @@
   uint8_t* pixels = static_cast<uint8_t*>(bitmap->getPixels());
 
   ignore_result(scoped_callback_runner.Release());
 
   gl_helper->CropScaleReadbackAndCleanMailbox(
       texture_mailbox.mailbox(), texture_mailbox.sync_token(), result->size(),
       gfx::Rect(result->size()), output_size_in_pixel, pixels, color_type,
       base::Bind(&CopyFromCompositingSurfaceFinished, callback,
                  base::Passed(&release_callback), base::Passed(&bitmap),
                  start_time, readback_lock),
-      display_compositor::GLHelper::SCALER_QUALITY_GOOD);
+      viz::GLHelper::SCALER_QUALITY_GOOD);
 }
 
 void RecordToolTypeForActionDown(const ui::MotionEventAndroid& event) {
   ui::MotionEventAndroid::Action action = event.GetAction();
   if (action == ui::MotionEventAndroid::ACTION_DOWN ||
       action == ui::MotionEventAndroid::ACTION_POINTER_DOWN ||
       action == ui::MotionEventAndroid::ACTION_BUTTON_PRESS) {
     UMA_HISTOGRAM_ENUMERATION("Event.AndroidActionDown.ToolType",
                               event.GetToolType(0),
                               ui::MotionEventAndroid::TOOL_TYPE_LAST + 1);
@@ skipping 1815 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content