Move Format checks to HardwareDisplayPlane

ui/ozone/platform/drm/gpu/hardware_display_plane_manager.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/gpu/hardware_display_plane_manager.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 83 matching lines @@
 
     uint32_t formats_size = drm_plane->count_formats;
     plane_ids.insert(drm_plane->plane_id);
     scoped_ptr<HardwareDisplayPlane> plane(
         CreatePlane(drm_plane->plane_id, drm_plane->possible_crtcs));
 
     std::vector<uint32_t> supported_formats(formats_size);
     for (uint32_t j = 0; j < formats_size; j++)
       supported_formats.push_back(drm_plane->formats[j]);
 
-    if (plane->Initialize(drm, supported_formats, false)) {
+    if (plane->Initialize(drm, supported_formats, false, false)) {
       // CRTC controllers always assume they have a cursor plane and the cursor
       // plane is updated via cursor specific DRM API. Hence, we dont keep
       // track of Cursor plane here to avoid re-using it for any other purpose.
       if (plane->type() != HardwareDisplayPlane::kCursor)
         planes_.push_back(plane.Pass());
     }
   }
 
   // crbug.com/464085: if driver reports no primary planes for a crtc, create a
   // dummy plane for which we can assign exactly one overlay.
   // TODO(dnicoara): refactor this to simplify AssignOverlayPlanes and move
   // this workaround into HardwareDisplayPlaneLegacy.
   if (!has_universal_planes) {
     for (int i = 0; i < resources->count_crtcs; ++i) {
       if (plane_ids.find(resources->crtcs[i] - 1) == plane_ids.end()) {
         scoped_ptr<HardwareDisplayPlane> dummy_plane(
             CreatePlane(resources->crtcs[i] - 1, (1 << i)));
-        if (dummy_plane->Initialize(drm, std::vector<uint32_t>(), true)) {
+        if (dummy_plane->Initialize(drm, std::vector<uint32_t>(), true,
+                                    false)) {
           planes_.push_back(dummy_plane.Pass());
         }
       }
     }
   }
 
   std::sort(planes_.begin(), planes_.end(),
             [](HardwareDisplayPlane* l, HardwareDisplayPlane* r) {
               return l->plane_id() < r->plane_id();
             });
@@ skipping 42 matching lines @@
     uint32_t crtc_id,
     CrtcController* crtc) {
   int crtc_index = LookupCrtcIndex(crtc_id);
   if (crtc_index < 0) {
     LOG(ERROR) << "Cannot find crtc " << crtc_id;
     return false;
   }
 
   size_t plane_idx = 0;
   for (const auto& plane : overlay_list) {
-    HardwareDisplayPlane* hw_plane =
-        FindNextUnusedPlane(&plane_idx, crtc_index, plane.buffer->GetFormat());
+    HardwareDisplayPlane* hw_plane = FindNextUnusedPlane(
+        &plane_idx, crtc_index, plane.buffer->GetFramebufferPixelFormat());
     if (!hw_plane) {
       LOG(ERROR) << "Failed to find a free plane for crtc " << crtc_id;
       return false;
     }
 
     gfx::Rect fixed_point_rect;
     if (hw_plane->type() != HardwareDisplayPlane::kDummy) {
       const gfx::Size& size = plane.buffer->GetSize();
       gfx::RectF crop_rect = plane.crop_rect;
       crop_rect.Scale(size.width(), size.height());
@@ skipping 14 matching lines @@
                      crtc)) {
       hw_plane->set_in_use(true);
     } else {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace ui