Revert of gpu: Use ANDROID_native_fence_sync instead of ARM_implicit_external_sync.

ui/ozone/platform/drm/gpu/gbm_surfaceless.cc

 // Copyright 2016 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 "ui/ozone/platform/drm/gpu/gbm_surfaceless.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 
 }  // namespace
 
 GbmSurfaceless::GbmSurfaceless(GbmSurfaceFactory* surface_factory,
                                std::unique_ptr<DrmWindowProxy> window,
                                gfx::AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       surface_factory_(surface_factory),
       window_(std::move(window)),
       widget_(widget),
-      has_native_fence_sync_(HasEGLExtension("EGL_ANDROID_native_fence_sync")),
+      has_implicit_external_sync_(
+          HasEGLExtension("EGL_ARM_implicit_external_sync")),
       weak_factory_(this) {
   surface_factory_->RegisterSurface(window_->widget(), this);
   unsubmitted_frames_.push_back(base::MakeUnique<PendingFrame>());
 }
 
 void GbmSurfaceless::QueueOverlayPlane(const OverlayPlane& plane) {
   planes_.push_back(plane);
 }
 
 bool GbmSurfaceless::Initialize(gl::GLSurfaceFormat format) {
@@ skipping 57 matching lines @@
 
   SwapCompletionCallback surface_swap_callback = base::Bind(
       &GbmSurfaceless::SwapCompleted, weak_factory_.GetWeakPtr(), callback);
 
   PendingFrame* frame = unsubmitted_frames_.back().get();
   frame->callback = surface_swap_callback;
   unsubmitted_frames_.push_back(base::MakeUnique<PendingFrame>());
 
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
-  EGLSyncKHR fence = InsertFence(has_native_fence_sync_);
+  EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
   if (!fence) {
     callback.Run(gfx::SwapResult::SWAP_FAILED);
     return;
   }
 
   base::Closure fence_wait_task =
       base::Bind(&WaitForFence, GetDisplay(), fence);
 
   base::Closure fence_retired_callback = base::Bind(
       &GbmSurfaceless::FenceRetired, weak_factory_.GetWeakPtr(), fence, frame);
@@ skipping 71 matching lines @@
       // propagate the failed state.
       frame->callback.Run(gfx::SwapResult::SWAP_FAILED);
       return;
     }
 
     window_->SchedulePageFlip(planes_, frame->callback);
     planes_.clear();
   }
 }
 
-EGLSyncKHR GbmSurfaceless::InsertFence(bool native) {
-  return eglCreateSyncKHR(
-      GetDisplay(), native ? EGL_SYNC_NATIVE_FENCE_ANDROID : EGL_SYNC_FENCE_KHR,
-      nullptr);
+EGLSyncKHR GbmSurfaceless::InsertFence(bool implicit) {
+  const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
+                                EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
+                                EGL_NONE};
+  return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR,
+                          implicit ? attrib_list : NULL);
 }
 
 void GbmSurfaceless::FenceRetired(EGLSyncKHR fence, PendingFrame* frame) {
   eglDestroySyncKHR(GetDisplay(), fence);
   frame->ready = true;
   SubmitFrame();
 }
 
 void GbmSurfaceless::SwapCompleted(const SwapCompletionCallback& callback,
                                    gfx::SwapResult result) {
   callback.Run(result);
   swap_buffers_pending_ = false;
   if (result == gfx::SwapResult::SWAP_FAILED) {
     last_swap_buffers_result_ = false;
     return;
   }
 
   SubmitFrame();
 }
 
 }  // namespace ui