Media Remoting Clean-up: Less-redundant naming, style consistency, etc.

media/remoting/situational_renderer_factory.h

 // 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.
 
-#ifndef MEDIA_REMOTING_REMOTING_RENDERER_FACTORY_H_
-#define MEDIA_REMOTING_REMOTING_RENDERER_FACTORY_H_
+#ifndef MEDIA_REMOTING_SITUATIONAL_RENDERER_FACTORY_H_
+#define MEDIA_REMOTING_SITUATIONAL_RENDERER_FACTORY_H_
 
 #include "media/base/renderer_factory.h"
-#include "media/remoting/remoting_renderer_controller.h"
+#include "media/remoting/user_experience_controller.h"
 
 namespace media {
+namespace remoting {
 
-// Create renderer for local playback or remoting according to info from
-// |remoting_renderer_controller|.
-class RemotingRendererFactory : public RendererFactory {
+// Creates Renderers for either local playback or remote playback, as directed
+// by the UserExperienceController.
+class SituationalRendererFactory : public RendererFactory {

[xjz, 2017/01/21 06:12:34]

naming nit: How about AdaptiveRendererFactory?

[miu, 2017/01/23 20:57:37]

Hmm...I had a hard time naming this class. Could you explain why you like
Adaptive better?

Other names I had considered (do you prefer any of these?):

1. ConditionalRendererFactory: because it creates different renderers based on
conditions

2. AdjuvantRendererFactory: because it is an extra actor that provides
supplemental functionality over DefaultRendererFactory

[xjz, 2017/01/23 23:08:13]

I hesitated between AdaptiveRendererFactory and ConditionalRendererFactory, and
chose AdaptiveRendererFactory because it adaptively creates different renderers
when condition changes. Conditional/SitualtionalRenderer sounds a little like it
only creates renderer on a kind of condition/situation. But still, I am not good
at naming, so leave this to you to decide whether change it or not. :)  

[miu, 2017/01/24 00:19:40]

Done. I suppose since the class owns the controller (which makes the decision),
you can extend that to mean the factory adapts.

  public:
-  RemotingRendererFactory(
+  SituationalRendererFactory(
       std::unique_ptr<RendererFactory> default_renderer_factory,
-      std::unique_ptr<RemotingRendererController> remoting_renderer_controller);
-  ~RemotingRendererFactory() override;
+      std::unique_ptr<UserExperienceController> controller);
+  ~SituationalRendererFactory() override;
 
   std::unique_ptr<Renderer> CreateRenderer(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       AudioRendererSink* audio_renderer_sink,
       VideoRendererSink* video_renderer_sink,
       const RequestSurfaceCB& request_surface_cb) override;
 
  private:
   const std::unique_ptr<RendererFactory> default_renderer_factory_;
-  const std::unique_ptr<RemotingRendererController>
-      remoting_renderer_controller_;
+  const std::unique_ptr<UserExperienceController> controller_;
 
-  DISALLOW_COPY_AND_ASSIGN(RemotingRendererFactory);
+  DISALLOW_COPY_AND_ASSIGN(SituationalRendererFactory);
 };
 
+}  // namespace remoting
 }  // namespace media
 
-#endif  // MEDIA_REMOTING_REMOTING_RENDERER_FACTORY_H_
+#endif  // MEDIA_REMOTING_SITUATIONAL_RENDERER_FACTORY_H_