media: MojoMediaClient method renames.

For methods that return a scoped_ptr, use Create* instead of Get*.

TEST=No functionality change.

Review URL: https://codereview.chromium.org/1228903004

Cr-Commit-Position: refs/heads/master@{#338194}

5 files changed, 41 insertions, 39 deletions

diff --git a/media/mojo/services/default_mojo_media_client.cc b/media/mojo/services/default_mojo_media_client.cc
index 5d19401..57bf900 100644
--- a/media/mojo/services/default_mojo_media_client.cc
+++ b/media/mojo/services/default_mojo_media_client.cc
@@ -38,31 +38,31 @@ class DefaultMojoMediaClient : public PlatformMojoMediaClient {
         audio_manager->GetDefaultOutputStreamParameters()));
   }
 
-  scoped_ptr<RendererFactory> GetRendererFactory(
+  scoped_ptr<RendererFactory> CreateRendererFactory(
       const scoped_refptr<MediaLog>& media_log) override {
     return make_scoped_ptr(new DefaultRendererFactory(media_log, nullptr,
                                                       *audio_hardware_config_));
   }
 
-  ScopedVector<AudioDecoder> GetAudioDecoders(
+  ScopedVector<AudioDecoder> CreateAudioDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log) override {
     NOTREACHED();
     return ScopedVector<AudioDecoder>();
   }
 
-  ScopedVector<VideoDecoder> GetVideoDecoders(
+  ScopedVector<VideoDecoder> CreateVideoDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log) override {
     NOTREACHED();
     return ScopedVector<VideoDecoder>();
   }
 
-  scoped_refptr<AudioRendererSink> GetAudioRendererSink() override {
+  scoped_refptr<AudioRendererSink> CreateAudioRendererSink() override {
     return new AudioOutputStreamSink();
   }
 
-  scoped_ptr<VideoRendererSink> GetVideoRendererSink(
+  scoped_ptr<VideoRendererSink> CreateVideoRendererSink(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override {
     return make_scoped_ptr(
         new NullVideoSink(false, base::TimeDelta::FromSecondsD(1.0 / 60),
@@ -73,7 +73,7 @@ class DefaultMojoMediaClient : public PlatformMojoMediaClient {
     return *audio_hardware_config_;
   }
 
-  scoped_ptr<CdmFactory> GetCdmFactory() override {
+  scoped_ptr<CdmFactory> CreateCdmFactory() override {
     return make_scoped_ptr(new DefaultCdmFactory());
   }
 
diff --git a/media/mojo/services/mojo_media_application.cc b/media/mojo/services/mojo_media_application.cc
index d046f0d..ecadb59 100644
--- a/media/mojo/services/mojo_media_application.cc
+++ b/media/mojo/services/mojo_media_application.cc
@@ -68,13 +68,14 @@ void MojoMediaApplication::Create(
 
 RendererFactory* MojoMediaApplication::GetRendererFactory() {
   if (!renderer_factory_)
-    renderer_factory_ = MojoMediaClient::Get()->GetRendererFactory(media_log_);
+    renderer_factory_ =
+        MojoMediaClient::Get()->CreateRendererFactory(media_log_);
   return renderer_factory_.get();
 }
 
 CdmFactory* MojoMediaApplication::GetCdmFactory() {
   if (!cdm_factory_)
-    cdm_factory_ = MojoMediaClient::Get()->GetCdmFactory();
+    cdm_factory_ = MojoMediaClient::Get()->CreateCdmFactory();
   return cdm_factory_.get();
 }
 
diff --git a/media/mojo/services/mojo_media_client.cc b/media/mojo/services/mojo_media_client.cc
index dce8d14..fb7e7ad 100644
--- a/media/mojo/services/mojo_media_client.cc
+++ b/media/mojo/services/mojo_media_client.cc
@@ -18,38 +18,38 @@ MojoMediaClient* MojoMediaClient::Get() {
   return g_mojo_media_client.Pointer();
 }
 
-scoped_ptr<RendererFactory> MojoMediaClient::GetRendererFactory(
+scoped_ptr<RendererFactory> MojoMediaClient::CreateRendererFactory(
     const scoped_refptr<MediaLog>& media_log) {
-  return mojo_media_client_->GetRendererFactory(media_log);
+  return mojo_media_client_->CreateRendererFactory(media_log);
 }
 
-ScopedVector<AudioDecoder> MojoMediaClient::GetAudioDecoders(
+ScopedVector<AudioDecoder> MojoMediaClient::CreateAudioDecoders(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<MediaLog>& media_log) {
-  return mojo_media_client_->GetAudioDecoders(media_task_runner, media_log);
+  return mojo_media_client_->CreateAudioDecoders(media_task_runner, media_log);
 }
 
-ScopedVector<VideoDecoder> MojoMediaClient::GetVideoDecoders(
+ScopedVector<VideoDecoder> MojoMediaClient::CreateVideoDecoders(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<MediaLog>& media_log) {
-  return mojo_media_client_->GetVideoDecoders(media_task_runner, media_log);
+  return mojo_media_client_->CreateVideoDecoders(media_task_runner, media_log);
 }
 
-scoped_refptr<AudioRendererSink> MojoMediaClient::GetAudioRendererSink() {
-  return mojo_media_client_->GetAudioRendererSink();
+scoped_refptr<AudioRendererSink> MojoMediaClient::CreateAudioRendererSink() {
+  return mojo_media_client_->CreateAudioRendererSink();
 }
 
-scoped_ptr<VideoRendererSink> MojoMediaClient::GetVideoRendererSink(
+scoped_ptr<VideoRendererSink> MojoMediaClient::CreateVideoRendererSink(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
-  return mojo_media_client_->GetVideoRendererSink(task_runner);
+  return mojo_media_client_->CreateVideoRendererSink(task_runner);
 }
 
 const AudioHardwareConfig& MojoMediaClient::GetAudioHardwareConfig() {
   return mojo_media_client_->GetAudioHardwareConfig();
 }
 
-scoped_ptr<CdmFactory> MojoMediaClient::GetCdmFactory() {
-  return mojo_media_client_->GetCdmFactory();
+scoped_ptr<CdmFactory> MojoMediaClient::CreateCdmFactory() {
+  return mojo_media_client_->CreateCdmFactory();
 }
 
 MojoMediaClient::MojoMediaClient()
diff --git a/media/mojo/services/mojo_media_client.h b/media/mojo/services/mojo_media_client.h
index b2068f4..f5e5ca2 100644
--- a/media/mojo/services/mojo_media_client.h
+++ b/media/mojo/services/mojo_media_client.h
@@ -27,25 +27,25 @@ class PlatformMojoMediaClient {
 
   // Returns the RendererFactory to be used by MojoRendererService. If returns
   // null, a RendererImpl will be used with audio/video decoders provided in
-  // GetAudioDecoders() and GetVideoDecoders().
-  virtual scoped_ptr<RendererFactory> GetRendererFactory(
+  // CreateAudioDecoders() and CreateVideoDecoders().
+  virtual scoped_ptr<RendererFactory> CreateRendererFactory(
       const scoped_refptr<MediaLog>& media_log) = 0;
 
   // The list of audio or video decoders for use with RendererImpl when
-  // GetRendererFactory() returns null. Ownership of the decoders is passed to
-  // the caller. The methods on each decoder will only be called on
+  // CreateRendererFactory() returns null. Ownership of the decoders is passed
+  // to the caller. The methods on each decoder will only be called on
   // |media_task_runner|. |media_log| should be used to log errors or important
   // status information.
-  virtual ScopedVector<AudioDecoder> GetAudioDecoders(
+  virtual ScopedVector<AudioDecoder> CreateAudioDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log) = 0;
-  virtual ScopedVector<VideoDecoder> GetVideoDecoders(
+  virtual ScopedVector<VideoDecoder> CreateVideoDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log) = 0;
 
   // The output sink used for rendering audio or video respectively.
-  virtual scoped_refptr<AudioRendererSink> GetAudioRendererSink() = 0;
-  virtual scoped_ptr<VideoRendererSink> GetVideoRendererSink(
+  virtual scoped_refptr<AudioRendererSink> CreateAudioRendererSink() = 0;
+  virtual scoped_ptr<VideoRendererSink> CreateVideoRendererSink(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) = 0;
 
   // The platform's audio hardware configuration.  Note, this must remain
@@ -53,7 +53,7 @@ class PlatformMojoMediaClient {
   virtual const AudioHardwareConfig& GetAudioHardwareConfig() = 0;
 
   // Returns the CdmFactory to be used by MojoCdmService.
-  virtual scoped_ptr<CdmFactory> GetCdmFactory() = 0;
+  virtual scoped_ptr<CdmFactory> CreateCdmFactory() = 0;
 };
 
 class MojoMediaClient {
@@ -63,19 +63,19 @@ class MojoMediaClient {
   static MojoMediaClient* Get();
 
   // Copy of the PlatformMojoMediaClient interface.
-  scoped_ptr<RendererFactory> GetRendererFactory(
+  scoped_ptr<RendererFactory> CreateRendererFactory(
       const scoped_refptr<MediaLog>& media_log);
-  ScopedVector<AudioDecoder> GetAudioDecoders(
+  ScopedVector<AudioDecoder> CreateAudioDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log);
-  ScopedVector<VideoDecoder> GetVideoDecoders(
+  ScopedVector<VideoDecoder> CreateVideoDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<MediaLog>& media_log);
-  scoped_refptr<AudioRendererSink> GetAudioRendererSink();
-  scoped_ptr<VideoRendererSink> GetVideoRendererSink(
+  scoped_refptr<AudioRendererSink> CreateAudioRendererSink();
+  scoped_ptr<VideoRendererSink> CreateVideoRendererSink(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
   const AudioHardwareConfig& GetAudioHardwareConfig();
-  scoped_ptr<CdmFactory> GetCdmFactory();
+  scoped_ptr<CdmFactory> CreateCdmFactory();
 
  private:
   friend struct base::DefaultLazyInstanceTraits<MojoMediaClient>;
diff --git a/media/mojo/services/mojo_renderer_service.cc b/media/mojo/services/mojo_renderer_service.cc
index 966c8e8..d1bf751e 100644
--- a/media/mojo/services/mojo_renderer_service.cc
+++ b/media/mojo/services/mojo_renderer_service.cc
@@ -44,8 +44,9 @@ MojoRendererService::MojoRendererService(
   scoped_refptr<base::SingleThreadTaskRunner> task_runner(
       base::MessageLoop::current()->task_runner());
   MojoMediaClient* mojo_media_client = MojoMediaClient::Get();
-  audio_renderer_sink_ = mojo_media_client->GetAudioRendererSink();
-  video_renderer_sink_ = mojo_media_client->GetVideoRendererSink(task_runner);
+  audio_renderer_sink_ = mojo_media_client->CreateAudioRendererSink();
+  video_renderer_sink_ =
+      mojo_media_client->CreateVideoRendererSink(task_runner);
 
   // Create renderer.
   if (renderer_factory) {
@@ -54,11 +55,11 @@ MojoRendererService::MojoRendererService(
   } else {
     scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
         task_runner, audio_renderer_sink_.get(),
-        mojo_media_client->GetAudioDecoders(task_runner, media_log).Pass(),
+        mojo_media_client->CreateAudioDecoders(task_runner, media_log).Pass(),
         mojo_media_client->GetAudioHardwareConfig(), media_log));
     scoped_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
         task_runner, video_renderer_sink_.get(),
-        mojo_media_client->GetVideoDecoders(task_runner, media_log).Pass(),
+        mojo_media_client->CreateVideoDecoders(task_runner, media_log).Pass(),
         true, nullptr, media_log));
     renderer_.reset(new RendererImpl(task_runner, audio_renderer.Pass(),
                                      video_renderer.Pass()));