Convert ozone/drm DisplaySnapshot_Param to DisplaySnapshotMojo

ui/ozone/platform/drm/common/drm_util.cc

 // Copyright 2014 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/common/drm_util.h"
 
 #include <drm_fourcc.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/containers/flat_map.h"
 #include "base/memory/ptr_util.h"
+#include "ui/display/types/display_mode.h"
+#include "ui/display/types/display_snapshot_mojo.h"
 #include "ui/display/util/edid_parser.h"
+#include "ui/ozone/common/display_snapshot_proxy.h"
 
 namespace ui {
 
 namespace {
 
 static const size_t kDefaultCursorWidth = 64;
 static const size_t kDefaultCursorHeight = 64;
 
 bool IsCrtcInUse(
     uint32_t crtc,
@@ skipping 281 matching lines @@
          lhs.vsync_start == rhs.vsync_start && lhs.vsync_end == rhs.vsync_end &&
          lhs.vtotal == rhs.vtotal && lhs.vscan == rhs.vscan &&
          lhs.flags == rhs.flags && strcmp(lhs.name, rhs.name) == 0;
 }
 
 DisplayMode_Params CreateDisplayModeParams(const drmModeModeInfo& mode) {
   DisplayMode_Params params;
   params.size = gfx::Size(mode.hdisplay, mode.vdisplay);
   params.is_interlaced = mode.flags & DRM_MODE_FLAG_INTERLACE;
   params.refresh_rate = GetRefreshRate(mode);
-
   return params;
 }
 
 DisplaySnapshot_Params CreateDisplaySnapshotParams(
     HardwareDisplayControllerInfo* info,
     int fd,
     const base::FilePath& sys_path,
     size_t device_index,
     const gfx::Point& origin) {
   DisplaySnapshot_Params params;
@@ skipping 47 matching lines @@
   // If no preferred mode is found then use the first one. Using the first one
   // since it should be the best mode.
   if (!params.has_native_mode && !params.modes.empty()) {
     params.has_native_mode = true;
     params.native_mode = params.modes.front();
   }
 
   return params;
 }
 
+// TODO(rjkroege): Remove in a subsequent CL once Mojo IPC is used everywhere.
+std::vector<DisplaySnapshot_Params> CreateParamsFromSnapshot(
+    const MovableDisplaySnapshots& displays) {
+  std::vector<DisplaySnapshot_Params> params;
+  for (auto& d : displays) {
+    DisplaySnapshot_Params p;
+
+    p.display_id = d->display_id();
+    p.origin = d->origin();
+    p.physical_size = d->physical_size();
+    p.type = d->type();
+    p.is_aspect_preserving_scaling = d->is_aspect_preserving_scaling();
+    p.has_overscan = d->has_overscan();
+    p.has_color_correction_matrix = d->has_color_correction_matrix();
+    p.display_name = d->display_name();
+    p.sys_path = d->sys_path();
+
+    std::vector<DisplayMode_Params> mode_params;
+    for (const auto& m : d->modes()) {
+      mode_params.push_back(GetDisplayModeParams(*m));
+    }
+    p.modes = mode_params;
+    p.edid = d->edid();
+
+    if (d->current_mode()) {
+      p.has_current_mode = true;
+      p.current_mode = GetDisplayModeParams(*d->current_mode());
+    }
+
+    if (d->native_mode()) {
+      p.has_native_mode = true;
+      p.native_mode = GetDisplayModeParams(*d->native_mode());
+    }
+
+    p.product_id = d->product_id();
+    p.string_representation = d->ToString();
+    p.maximum_cursor_size = d->maximum_cursor_size();
+
+    params.push_back(p);
+  }
+  return params;
+}
+
 int GetFourCCFormatFromBufferFormat(gfx::BufferFormat format) {
   switch (format) {
     case gfx::BufferFormat::R_8:
       return DRM_FORMAT_R8;
     case gfx::BufferFormat::RG_88:
       return DRM_FORMAT_GR88;
     case gfx::BufferFormat::RGBA_8888:
       return DRM_FORMAT_ABGR8888;
     case gfx::BufferFormat::RGBX_8888:
       return DRM_FORMAT_XBGR8888;
@@ skipping 60 matching lines @@
       return DRM_FORMAT_UYVY;
     case gfx::BufferFormat::YUV_420_BIPLANAR:
       return DRM_FORMAT_NV12;
     case gfx::BufferFormat::YVU_420:
       return DRM_FORMAT_YVU420;
     default:
       NOTREACHED();
       return 0;
   }
 }
+
+MovableDisplaySnapshots CreateMovableDisplaySnapshotsFromParams(
+    const std::vector<DisplaySnapshot_Params>& displays) {
+  MovableDisplaySnapshots snapshots;
+  for (const auto& d : displays)
+    snapshots.push_back(base::MakeUnique<DisplaySnapshotProxy>(d));
+  return snapshots;
+}
+
 }  // namespace ui