GpuService: introduce GetGpuMemoryBufferAttribs as a mojo interface

services/ui/gpu/gpu_service.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 "services/ui/gpu/gpu_service.h"
 
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/memory/shared_memory.h"
@@ skipping 223 matching lines @@
                                         const gpu::SyncToken& sync_token) {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::DestroyGpuMemoryBuffer, weak_ptr_,
                               id, client_id, sync_token));
     return;
   }
   gpu_channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
 }
 
+void GpuService::GetGpuMemoryBufferAttribs(
+    const GetGpuMemoryBufferAttribsCallback& callback) {
+  gfx::GpuMemoryBufferAttribVector supported_attribs;
+
+  for (int i = 0; i < static_cast<int>(gfx::BufferUsage::LAST); i++) {
+    gfx::GpuMemoryBufferAttribVector tmp =
+        gpu_memory_buffer_factory_->GetSupportedGpuMemoryBufferAttribsForUsage(
+            static_cast<gfx::BufferUsage>(i));
+    if (tmp.size() == 0)
+      continue;
+
+    gfx::GpuMemoryBufferAttribVector intersection;
+    std::sort(tmp.begin(), tmp.end());
+
+    if (supported_attribs.size() == 0)
+      supported_attribs = std::move(tmp);
+    else {
+      std::set_intersection(supported_attribs.begin(), supported_attribs.end(),
+                            tmp.begin(), tmp.end(),
+                            std::back_inserter(intersection));
+      supported_attribs = std::move(intersection);
+    }
+  }
+
+  callback.Run(supported_attribs);

[sadrul, 2017/04/19 21:40:23]

Do we expect this list to change between requests? If not, can we cache it
during the first call, so that we don't have to do the work again for subsequent
calls?

[varad, 2017/04/21 13:01:32]

Done.

+}
+
 void GpuService::GetVideoMemoryUsageStats(
     const GetVideoMemoryUsageStatsCallback& callback) {
   if (io_runner_->BelongsToCurrentThread()) {
     auto wrap_callback = WrapCallback(io_runner_, callback);
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::GetVideoMemoryUsageStats, weak_ptr_,
                               wrap_callback));
     return;
   }
   gpu::VideoMemoryUsageStats video_memory_usage_stats;
@@ skipping 244 matching lines @@
 
 void GpuService::Stop(const StopCallback& callback) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTaskAndReply(FROM_HERE, base::Bind([] {
                                    base::MessageLoop::current()->QuitWhenIdle();
                                  }),
                                  callback);
 }
 
 }  // namespace ui