[chrome.displaySource][WiFi Display] Consider video encoder capabilities

extensions/renderer/api/display_source/wifi_display/wifi_display_media_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 "extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/task_runner_util.h"
 #include "content/public/common/service_registry.h"
@@ skipping 266 matching lines @@
             format->frame_rate == table[i].frame_rate) {
           result->rate_resolution = table[i].rr;
           result->type = type;
           return true;
         }
      }
   }
   return false;
 }
 
-bool FindOptimalFormat(
+void FindCompatibleFormats(
     const media::VideoCaptureFormat* capture_format,
     const std::vector<wds::H264VideoCodec>& sink_supported_codecs,
-    wds::H264VideoFormat* result /*out*/) {
+    std::vector<wds::H264VideoFormat>* result /*out*/) {
   DCHECK(result);
   for (const wds::H264VideoCodec& codec : sink_supported_codecs) {
+    wds::H264VideoFormat format;
     bool found =
         FindRateResolution<wds::CEA>(
-            capture_format, codec.cea_rr, cea_table, result) ||
+            capture_format, codec.cea_rr, cea_table, &format) ||
         FindRateResolution<wds::VESA>(
-            capture_format, codec.vesa_rr, vesa_table, result) ||
+            capture_format, codec.vesa_rr, vesa_table, &format) ||
         FindRateResolution<wds::HH>(
-            capture_format, codec.hh_rr, hh_table, result);
+            capture_format, codec.hh_rr, hh_table, &format);
     if (found) {
-      result->profile = codec.profile;
-      result->level = codec.level;
-      return true;
+      format.profile = codec.profile;
+      format.level = codec.level;
+      result->emplace_back(format);
     }
   }
-  return false;
 }
 
 }  // namespace
 
 wds::H264VideoFormat WiFiDisplayMediaManager::GetOptimalVideoFormat() const {
   return optimal_video_format_;
 }
 
 namespace {
 
@@ skipping 24 matching lines @@
 bool WiFiDisplayMediaManager::InitOptimalVideoFormat(
     const wds::NativeVideoFormat& sink_native_format,
     const std::vector<wds::H264VideoCodec>& sink_supported_codecs) {
   const media::VideoCaptureFormat* capture_format =
       content::GetCurrentVideoTrackFormat(video_track_);
   if (!capture_format) {
     error_callback_.Run(kErrorNoVideoFormatData);
     return false;
   }
 
-  if (!FindOptimalFormat(
-      capture_format, sink_supported_codecs, &optimal_video_format_)) {
+  std::vector<wds::H264VideoFormat> compatible_formats;
+
+  FindCompatibleFormats(
+      capture_format, sink_supported_codecs, &compatible_formats);
+
+  if (compatible_formats.empty()) {
     error_callback_.Run(kErrorSinkCannotPlayVideo);
     return false;
   }
+
+  // The found compatible formats have the same frame rate and resolution but
+  // different video encoder profiles. Pick the appropriate profile from the
+  // supported by video encoder.
+  std::vector<wds::H264Profile> supported_profiles =
+      WiFiDisplayVideoEncoder::FindSupportedProfiles(
+          capture_format->frame_size,
+          capture_format->frame_rate);
+
+  if (supported_profiles.empty()) {
+    error_callback_.Run(kErrorSinkCannotPlayVideo);
+    return false;
+  }
+
+  bool profile_found = false;
+  for (wds::H264Profile profile : supported_profiles) {
+    if (profile_found)
+      break;
+
+    for (const auto& format : compatible_formats) {
+      if (format.profile == profile) {
+         optimal_video_format_ = format;
+         profile_found = true;
+         break;
+      }
+    }
+  }
+
+  if (!profile_found) {
+    error_callback_.Run(kErrorSinkCannotPlayVideo);
+    return false;
+  }
+
   video_encoder_parameters_.frame_size = capture_format->frame_size;
   video_encoder_parameters_.frame_rate =
       static_cast<int>(capture_format->frame_rate);
   video_encoder_parameters_.bit_rate = GetBitRate(capture_format->frame_size);
   video_encoder_parameters_.profile = optimal_video_format_.profile;
   video_encoder_parameters_.level = optimal_video_format_.level;
   video_encoder_parameters_.create_memory_callback =
       media::BindToCurrentLoop(base::Bind(&CreateVideoEncodeMemory));
   video_encoder_parameters_.vea_create_callback =
       media::BindToCurrentLoop(
@@ skipping 82 matching lines @@
       media::BindToCurrentLoop(on_completed));
 }
 
 void WiFiDisplayMediaManager::ConnectToRemoteService(
     WiFiDisplayMediaServiceRequest request) {
   DCHECK(content::RenderThread::Get());
   service_registry_->ConnectToRemoteService(std::move(request));
 }
 
 }  // namespace extensions