Use OS_LINUX instead of USE_OZONE in ui/gfx/ when possible

ui/gfx/mojo/buffer_types_struct_traits.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/gfx/mojo/buffer_types_struct_traits.h"
 
 #include "mojo/public/cpp/system/platform_handle.h"
 
 namespace mojo {
 
 void* StructTraits<gfx::mojom::NativePixmapHandleDataView,
                    gfx::NativePixmapHandle>::
     SetUpContext(const gfx::NativePixmapHandle& pixmap_handle) {
   return new PixmapHandleFdList();
 }
 
 void StructTraits<gfx::mojom::NativePixmapHandleDataView,
                   gfx::NativePixmapHandle>::
     TearDownContext(const gfx::NativePixmapHandle& handle, void* context) {
   delete static_cast<PixmapHandleFdList*>(context);
 }
 
 std::vector<mojo::ScopedHandle> StructTraits<
     gfx::mojom::NativePixmapHandleDataView,
     gfx::NativePixmapHandle>::fds(const gfx::NativePixmapHandle& pixmap_handle,
                                   void* context) {
   PixmapHandleFdList* handles = static_cast<PixmapHandleFdList*>(context);
-#if defined(USE_OZONE)
+#if defined(OS_LINUX)
   if (handles->empty()) {
     // Generate the handles here, but do not send them yet.
     for (const base::FileDescriptor& fd : pixmap_handle.fds) {
       base::PlatformFile platform_file = fd.fd;
       handles->push_back(mojo::WrapPlatformFile(platform_file));
     }
     return PixmapHandleFdList(handles->size());
   }
-#endif  // defined(USE_OZONE)
+#endif  // defined(OS_LINUX)
   return std::move(*handles);
 }
 
 bool StructTraits<
     gfx::mojom::NativePixmapHandleDataView,
     gfx::NativePixmapHandle>::Read(gfx::mojom::NativePixmapHandleDataView data,
                                    gfx::NativePixmapHandle* out) {
-#if defined(USE_OZONE)
+#if defined(OS_LINUX)
   mojo::ArrayDataView<mojo::ScopedHandle> handles_data_view;
   data.GetFdsDataView(&handles_data_view);
   for (size_t i = 0; i < handles_data_view.size(); ++i) {
     mojo::ScopedHandle handle = handles_data_view.Take(i);
     base::PlatformFile platform_file;
     if (mojo::UnwrapPlatformFile(std::move(handle), &platform_file) !=
         MOJO_RESULT_OK)
       return false;
     constexpr bool auto_close = true;
     out->fds.push_back(base::FileDescriptor(platform_file, auto_close));
@@ skipping 26 matching lines @@
   platform_file = handle.handle.fd;
 #endif
   return mojo::WrapPlatformFile(platform_file);
 #endif  // defined(OS_MACOSX)
 }
 
 const gfx::NativePixmapHandle&
 StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
              gfx::GpuMemoryBufferHandle>::
     native_pixmap_handle(const gfx::GpuMemoryBufferHandle& handle) {
-#if defined(USE_OZONE)
+#if defined(OS_LINUX)
   return handle.native_pixmap_handle;
 #else
   static gfx::NativePixmapHandle pixmap_handle;
   return pixmap_handle;
 #endif
 }
 
 mojo::ScopedHandle StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
                                 gfx::GpuMemoryBufferHandle>::
     mach_port(const gfx::GpuMemoryBufferHandle& handle) {
@@ skipping 35 matching lines @@
           base::SharedMemoryHandle(platform_file, base::GetCurrentProcId());
 #else
       out->handle = base::SharedMemoryHandle(platform_file, true);
 #endif
 #endif  // defined(OS_MACOSX)
     }
 
     out->offset = data.offset();
     out->stride = data.stride();
   }
-#if defined(USE_OZONE)
+#if defined(OS_LINUX)
   if (out->type == gfx::OZONE_NATIVE_PIXMAP &&
       !data.ReadNativePixmapHandle(&out->native_pixmap_handle))
     return false;
 #endif
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   if (out->type == gfx::IO_SURFACE_BUFFER) {
     mach_port_t mach_port;
     MojoResult unwrap_result =
         mojo::UnwrapMachPort(data.TakeMachPort(), &mach_port);
     if (unwrap_result != MOJO_RESULT_OK)
       return false;
     out->mach_port.reset(mach_port);
   }
 #endif
   return true;
 }
 
 }  // namespace mojo