NotForReview: Implement zero/one-copy texture for ozone freon using Intel DRM

cc/resources/resource_provider.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 683 matching lines @@
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = NULL;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::INTERNAL);
     delete[] resource->pixels;
     resource->pixels = NULL;
   }
   if (resource->gpu_memory_buffer) {
+    // TODO(dshwang): It can fix glitch and crash bugs for Ozone GBM
+    // I guess the root reason is originated from kernel bug, but it
+    // demonstrates it's possible to workaround in chromium.
+    // ContextGL()->Finish();

[dshwang, 2015/04/09 19:12:26]

This glFinish almost fix the glitch bug.
So I try to delete |gpu_memory_buffer| in GPU Process 1 sec after receiving
GpuMsg_DestroyGpuMemoryBuffer message without glFinish, but it doesn't fix the
bug. It might be drm bug in linux kernel, but I'm finding workaround in chromium

     DCHECK(resource->origin == Resource::INTERNAL);
     delete resource->gpu_memory_buffer;
     resource->gpu_memory_buffer = NULL;
   }
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
@@ skipping 356 matching lines @@
     ~ScopedWriteLockGpuMemoryBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->UnlockForWrite(resource_);
   if (!gpu_memory_buffer_)
     return;
 
   if (!resource_->image_id) {
     GLES2Interface* gl = resource_provider_->ContextGL();
     DCHECK(gl);
 
-#if defined(OS_CHROMEOS)
-    // TODO(reveman): GL_COMMANDS_ISSUED_CHROMIUM is used for synchronization
-    // on ChromeOS to avoid some performance issues. This only works with
-    // shared memory backed buffers. crbug.com/436314
-    DCHECK_EQ(gpu_memory_buffer_->GetHandle().type, gfx::SHARED_MEMORY_BUFFER);
-#endif
-
     resource_->image_id = gl->CreateImageCHROMIUM(
         gpu_memory_buffer_->AsClientBuffer(), size_.width(), size_.height(),
         GLInternalFormat(resource_->format));
   }
 
   std::swap(resource_->gpu_memory_buffer, gpu_memory_buffer_);
   resource_->allocated = true;
   resource_->dirty_image = true;
 
   // GpuMemoryBuffer provides direct access to the memory used by the GPU.
@@ skipping 962 matching lines @@
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   if (source_resource->image_id && source_resource->dirty_image) {
     gl->BindTexture(source_resource->target, source_resource->gl_id);
     BindImageForSampling(source_resource);
   }
   if (use_sync_query_) {
     if (!source_resource->gl_read_lock_query_id)
       gl->GenQueriesEXT(1, &source_resource->gl_read_lock_query_id);
 #if defined(OS_CHROMEOS)
-    // TODO(reveman): This avoids a performance problem on some ChromeOS
-    // devices. This needs to be removed to support native GpuMemoryBuffer
-    // implementations. crbug.com/436314
-    gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
-                      source_resource->gl_read_lock_query_id);
-#else
+    // TODO(reveman): GL_COMMANDS_ISSUED_CHROMIUM is used for synchronization

[reveman, 2015/04/13 00:46:13]

We'll need to fix this TODO instead.

[dshwang, 2015/04/14 13:15:55]

It's Exynos 5 workaround. Even if vgem one-copy is landed, it's behind
--enable-native-gpu-memory-buffers flags. So software one-copy in Exynos 5 still
has this issue. It would be fixed in separate CL.

+    // on ChromeOS to avoid some performance issues. This only works with
+    // shared memory backed buffers. crbug.com/436314
+    if (source_resource->gpu_memory_buffer->GetHandle().type ==
+        gfx::SHARED_MEMORY_BUFFER)
+      gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
+                        source_resource->gl_read_lock_query_id);
+    else
+#endif
     gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
-#endif
   }
   DCHECK(!dest_resource->image_id);
   dest_resource->allocated = true;
   gl->CopySubTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
                              dest_resource->gl_id, 0, 0);
   if (source_resource->gl_read_lock_query_id) {
     // End query and create a read lock fence that will prevent access to
 // source resource until CopySubTextureCHROMIUM command has completed.
 #if defined(OS_CHROMEOS)
-    gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
-#else
-    gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
+    if (source_resource->gpu_memory_buffer->GetHandle().type ==
+        gfx::SHARED_MEMORY_BUFFER)
+      gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
+    else
 #endif
+      gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
     source_resource->read_lock_fence = make_scoped_refptr(
         new CopyTextureFence(gl, source_resource->gl_read_lock_query_id));
   } else {
     // Create a SynchronousFence when CHROMIUM_sync_query extension is missing.
     // Try to use one synchronous fence for as many CopyResource operations as
     // possible as that reduce the number of times we have to synchronize with
     // the GL.
     if (!synchronous_fence_.get() || synchronous_fence_->has_synchronized())
       synchronous_fence_ = make_scoped_refptr(new SynchronousFence(gl));
     source_resource->read_lock_fence = synchronous_fence_;
@@ skipping 44 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc