Pass Connector* into MojoMediaClient::Initialize().

media/mojo/services/android_mojo_media_client.cc

 // Copyright 2015 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 "media/mojo/services/android_mojo_media_client.h"
 
 #include "base/memory/ptr_util.h"
 #include "media/base/android/android_cdm_factory.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/cdm_factory.h"
 #include "media/filters/android/media_codec_audio_decoder.h"
 #include "media/mojo/interfaces/provision_fetcher.mojom.h"
 #include "media/mojo/services/mojo_provision_fetcher.h"
 #include "services/service_manager/public/cpp/connect.h"
 
 namespace media {
 
 namespace {
 
 std::unique_ptr<ProvisionFetcher> CreateProvisionFetcher(
-    service_manager::mojom::InterfaceProvider* interface_provider) {
+    service_manager::mojom::InterfaceProvider* host_interfaces) {
   mojom::ProvisionFetcherPtr provision_fetcher_ptr;
-  service_manager::GetInterface(interface_provider, &provision_fetcher_ptr);
+  service_manager::GetInterface(host_interfaces, &provision_fetcher_ptr);
   return base::MakeUnique<MojoProvisionFetcher>(
       std::move(provision_fetcher_ptr));
 }
 
 }  // namespace
 
 AndroidMojoMediaClient::AndroidMojoMediaClient() {}
 
 AndroidMojoMediaClient::~AndroidMojoMediaClient() {}
 
 // MojoMediaClient overrides.
 
 std::unique_ptr<AudioDecoder> AndroidMojoMediaClient::CreateAudioDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   return base::MakeUnique<MediaCodecAudioDecoder>(task_runner);
 }
 
 std::unique_ptr<CdmFactory> AndroidMojoMediaClient::CreateCdmFactory(
-    service_manager::mojom::InterfaceProvider* interface_provider) {
+    service_manager::mojom::InterfaceProvider* host_interfaces) {
+  // |host_interfaces| is needed for CDM. If it was not bound by the host,
+  // return nullptr.
+  if (!host_interfaces)
+    return nullptr;

[dcheng, 2016/12/02 08:52:51]

Just trying to understand the change here: does hitting this mean that there's a
programming error? Is there any reason why code would be calling this with no
host interfaces? Or does this client simply not know?

[slan, 2016/12/02 16:45:53]

|host_interfaces| is, at present, used to provide interfaces specific to the
render frame. This change provides flexibility to clients who do not need to
provide additional interfaces, or who know nothing about render frames, but
still want to consume the "media" service.

Xiaohan may be able to provide specifics on what the Android use cases for this
are (perhaps some media playback of non-protected content from another context).
On Chromecast, we have several applications that will benefit from this
flexibility.

This pattern deviates from how interfaces requests should be brokered between
services (crbug.com/660573). Making this parameter optional takes a step in the
right direction for correcting this behavior.

[xhwang, 2016/12/02 17:47:48]

dcheng: good point. I think when this happens, it's generally a programming
error, thus a DCHECK is typically the recommendation. However, as slan@
mentioned, with the flexibility of mojo, there are many different ways to config
the system to use the media service with this client, and I was afraid when the
system was misconfiged we could end up here. This is similar to the current
warning/failure in mojo connector where a client tries to connect to an
interface, but no interface implementation is registered.

With that, maybe this will make more sense?

if (!host_interfaces) {
  NOTREACHED() << "Host interface should be provided when using CDM with
AndroidMojoMediaClient";
  return nullptr;
}

[dcheng, 2016/12/02 18:00:30]

I feel like a NOTREACHED() will just end up mostly ignored?

Also, my uncertainty about what to do here comes from my confusion about the
process model in media: I poked around a bit, and I /think/ this is running in
the unprivileged process... but I'm not 100% certain either. But in that case,
it's the unprivileged process making a programming error, so it would be useful
to fail early instead?

   return base::MakeUnique<AndroidCdmFactory>(
-      base::Bind(&CreateProvisionFetcher, interface_provider));
+      base::Bind(&CreateProvisionFetcher, host_interfaces));
 }
 
 }  // namespace media