ozone: introduce OverlayCheckReturn_Params

ui/ozone/platform/drm/host/drm_overlay_manager.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/host/drm_overlay_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 44 matching lines @@
     }
 
     // Compositor doesn't have information about the total size of primary
     // candidate. We get this information from display rect.
     if (candidate.plane_z_order == 0)
       candidate.buffer_size = gfx::ToNearestRect(candidate.display_rect).size();
 
     overlay_params.push_back(OverlayCheck_Params(candidate));
   }
 
+  size_t size = candidates->size();
   const auto& iter = cache_.Get(overlay_params);
-  // We are still waiting on results for this candidate list from GPU.
-  if (iter != cache_.end() && iter->second)
+  if (iter != cache_.end()) {
+    // We are still waiting on results for this candidate list from GPU.
+    if (iter->second.back().status ==
+        OverlayCheckReturn_Params::Status::Pending)
+      return;
+
+    const std::vector<OverlayCheckReturn_Params>& returns = iter->second;
+    DCHECK(size == returns.size());
+    for (size_t i = 0; i < size; i++) {
+      DCHECK(returns[i].status == OverlayCheckReturn_Params::Status::Able ||
+             returns[i].status == OverlayCheckReturn_Params::Status::Not);
+      candidates->at(i).overlay_handled =
+          returns[i].status == OverlayCheckReturn_Params::Status::Able ? true
+                                                                       : false;
+    }
     return;
+  }
 
-  size_t size = candidates->size();
+  // We can skip GPU side validation in case all candidates are invalid.
+  bool needs_gpu_validation = false;
+  for (size_t i = 0; i < size; i++) {
+    if (!overlay_params.at(i).is_overlay_candidate)
+      continue;
 
-  if (iter == cache_.end()) {
-    // We can skip GPU side validation in case all candidates are invalid.
-    bool needs_gpu_validation = false;
-    for (size_t i = 0; i < size; i++) {
-      if (!overlay_params.at(i).is_overlay_candidate)
-        continue;
-
-      const OverlaySurfaceCandidate& candidate = candidates->at(i);
-      if (!CanHandleCandidate(candidate, widget)) {
-        DCHECK(candidate.plane_z_order != 0);
-        overlay_params.at(i).is_overlay_candidate = false;
-        continue;
-      }
-
-      needs_gpu_validation = true;
+    const OverlaySurfaceCandidate& candidate = candidates->at(i);
+    if (!CanHandleCandidate(candidate, widget)) {
+      DCHECK(candidate.plane_z_order != 0);

[dnicoara, 2017/06/02 21:31:25]

Why did you removed the "overlay_params.at(i).is_overlay_candidate = false;"
statement?

[dshwang, 2017/06/02 23:59:00]

I didn't like to change the key after querying `cache_.Get(overlay_params);`
already at line 66. and I thought gpu process can handle it. However, I have
better idea now. see next patch set.

+      continue;
     }
 
-    cache_.Put(overlay_params, needs_gpu_validation);
+    needs_gpu_validation = true;
+  }
 
-    if (needs_gpu_validation)
-      SendOverlayValidationRequest(overlay_params, widget);
-  } else {
-    const std::vector<OverlayCheck_Params>& validated_params = iter->first;
-    DCHECK(size == validated_params.size());
-
-    for (size_t i = 0; i < size; i++) {
-      candidates->at(i).overlay_handled =
-          validated_params.at(i).is_overlay_candidate;
+  std::vector<OverlayCheckReturn_Params> returns(overlay_params.size());
+  if (needs_gpu_validation) {
+    for (auto param : returns) {
+      param.status = OverlayCheckReturn_Params::Status::Not;
     }
   }
+
+  cache_.Put(overlay_params, returns);
+
+  if (needs_gpu_validation)
+    SendOverlayValidationRequest(overlay_params, widget);
 }
 
 void DrmOverlayManager::ResetCache() {
   cache_.Clear();
 }
 
 void DrmOverlayManager::SendOverlayValidationRequest(
     const std::vector<OverlayCheck_Params>& new_params,
     gfx::AcceleratedWidget widget) const {
   if (!proxy_->IsConnected())
     return;
 
   proxy_->GpuCheckOverlayCapabilities(widget, new_params);
 }
 
 void DrmOverlayManager::GpuSentOverlayResult(
     gfx::AcceleratedWidget widget,
-    const std::vector<OverlayCheck_Params>& params) {
-  cache_.Put(params, false);

[dshwang, 2017/05/31 21:05:11]

It's the root of potential bug.

params.back().is_overlay_candidate can be false, while the requested
params.back().is_overlay_candidate is true. And then the request lost the key.

This CL separate request input (i.e. is_overlay_candidate) and response output
(i.e. status)

+    const std::vector<OverlayCheck_Params>& params,
+    const std::vector<OverlayCheckReturn_Params>& returns) {
+  cache_.Put(params, returns);
 }
 
 bool DrmOverlayManager::CanHandleCandidate(
     const OverlaySurfaceCandidate& candidate,
     gfx::AcceleratedWidget widget) const {
   if (candidate.buffer_size.IsEmpty())
     return false;
 
   if (candidate.transform == gfx::OVERLAY_TRANSFORM_INVALID)
     return false;
@@ skipping 12 matching lines @@
   }
 
   if (candidate.is_clipped &&
       !candidate.clip_rect.Contains(candidate.quad_rect_in_target_space))
     return false;
 
   return true;
 }
 
 }  // namespace ui