[chrome.displaySource] Use InterfaceProvider instead of ServiceRegistry.

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"
 #include "content/public/renderer/media_stream_utils.h"
 #include "content/public/renderer/media_stream_video_sink.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/video_encode_accelerator.h"
 #include "extensions/common/mojo/wifi_display_session_service.mojom.h"
 #include "extensions/renderer/api/display_source/wifi_display/wifi_display_elementary_stream_info.h"
 #include "extensions/renderer/api/display_source/wifi_display/wifi_display_media_pipeline.h"
 #include "media/base/bind_to_current_loop.h"
+#include "services/shell/public/cpp/interface_provider.h"
 
 namespace extensions {
 
 namespace {
 
 const char kErrorNoVideoFormatData[] =
     "Failed to get video format data from the given MediaStreamTrack object";
 const char kErrorSinkCannotPlayVideo[] =
     "The sink cannot play video from the given MediaStreamTrack object";
 const char kErrorSinkCannotPlayAudio[] =
@@ skipping 50 matching lines @@
  private:
   blink::WebMediaStreamTrack track_;
   content::VideoCaptureDeliverFrameCB callback_;
   DISALLOW_COPY_AND_ASSIGN(WiFiDisplayVideoSink);
 };
 
 WiFiDisplayMediaManager::WiFiDisplayMediaManager(
     const blink::WebMediaStreamTrack& video_track,
     const blink::WebMediaStreamTrack& audio_track,
     const std::string& sink_ip_address,
-    content::ServiceRegistry* service_registry,
+    shell::InterfaceProvider* interface_provider,
     const ErrorCallback& error_callback)
     : video_track_(video_track),
       audio_track_(audio_track),
-      service_registry_(service_registry),
+      interface_provider_(interface_provider),
       sink_ip_address_(sink_ip_address),
       player_(nullptr),
       io_task_runner_(content::RenderThread::Get()->GetIOTaskRunner()),
       error_callback_(error_callback),
       is_playing_(false),
       is_initialized_(false),
       weak_factory_(this) {
   DCHECK(!video_track.isNull() || !audio_track.isNull());
-  DCHECK(service_registry_);
+  DCHECK(interface_provider_);
   DCHECK(!error_callback_.is_null());
 }
 
 WiFiDisplayMediaManager::~WiFiDisplayMediaManager() {
   Teardown();
 }
 
 void WiFiDisplayMediaManager::Play() {
   is_playing_ = true;
   if (!player_) {
@@ skipping 368 matching lines @@
                  base::Unretained(this),
                  base::Passed(&request));
   main_runner->PostTaskAndReply(FROM_HERE,
       connect_service_callback,
       media::BindToCurrentLoop(on_completed));
 }
 
 void WiFiDisplayMediaManager::ConnectToRemoteService(
     WiFiDisplayMediaServiceRequest request) {
   DCHECK(content::RenderThread::Get());
-  service_registry_->ConnectToRemoteService(std::move(request));
+  interface_provider_->GetInterface(std::move(request));
 }
 
 }  // namespace extensions