Motown: wholesale clang-format

services/media/factory_service/media_player_impl.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 MOJO_SERVICES_MEDIA_FACTORY_MEDIA_PLAYER_IMPL_H_
 #define MOJO_SERVICES_MEDIA_FACTORY_MEDIA_PLAYER_IMPL_H_
 
 #include <deque>
 #include <limits>
 #include <vector>
 
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/services/media/common/interfaces/media_transport.mojom.h"
 #include "mojo/services/media/control/interfaces/media_factory.mojom.h"
 #include "services/media/factory_service/factory_service.h"
 #include "services/media/factory_service/watched.h"
 
 namespace mojo {
 namespace media {
 
 // Mojo agent that renders streams from an origin specified by URL.
-class MediaPlayerImpl
-    : public MediaFactoryService::Product,
-      public MediaPlayer {
+class MediaPlayerImpl : public MediaFactoryService::Product,
+                        public MediaPlayer {
  public:
   static std::shared_ptr<MediaPlayerImpl> Create(
       const String& originUrl,
       InterfaceRequest<MediaPlayer> request,
       MediaFactoryService* owner);
 
   ~MediaPlayerImpl() override;
 
   // MediaPlayer implementation.
-  void GetStatus(uint64_t version_last_seen, const GetStatusCallback& callback)
-      override;
+  void GetStatus(uint64_t version_last_seen,
+                 const GetStatusCallback& callback) override;
 
   void Play() override;
 
   void Pause() override;
 
   void Seek(int64_t position) override;
 
  private:
   const int64_t kNotSeeking = std::numeric_limits<int64_t>::max();
 
   struct Stream {
     Stream();
     ~Stream();
     bool enabled_ = false;
     Watched<MediaState> state_;
     MediaSourceStreamDescriptorPtr descriptor_;
     MediaTypeConverterPtr decoder_;
     MediaSinkPtr sink_;
     MediaProducerPtr encoded_producer_;
     MediaProducerPtr decoded_producer_;
   };
 
-  MediaPlayerImpl(
-      const String& originUrl,
-      InterfaceRequest<MediaPlayer> request,
-      MediaFactoryService* owner);
+  MediaPlayerImpl(const String& originUrl,
+                  InterfaceRequest<MediaPlayer> request,
+                  MediaFactoryService* owner);
 
   // Handles events in paused state.
   void WhenPaused();
 
   // Handles events in playing state.
   void WhenPlaying();
 
   // Handles events when seeking in paused state.
   void WhenPausedAndSeeking();
 
   // Handles events when seeking with flushed pipeline.
   void WhenFlushedAndSeeking();
 
   // Tells the sinks to change state and returns an Event that occurs when this
   // is accomplished.
   Event ChangeSinkStates(MediaState media_state);
 
   // Returns an Event the occurs when all sinks are in the indicated state.
   Event AllSinkStatesBecome(MediaState media_state);
 
   // Sets the reported_media_state_ field, calling StatusUpdated as needed.
   void SetReportedMediaState(MediaState media_state);
 
   // Prepares a stream.
   Event PrepareStream(const std::unique_ptr<Stream>& stream, const String& url);
 
   // Creates a sink for a stream.
   // TODO(dalesat): Use raw pointers rather than const std::unique_ptr<>&.
-  void CreateSink(
-      const std::unique_ptr<Stream>& stream,
-      const MediaTypePtr& input_media_type,
-      const String& url,
-      Event event);
+  void CreateSink(const std::unique_ptr<Stream>& stream,
+                  const MediaTypePtr& input_media_type,
+                  const String& url,
+                  Event event);
 
   // Increments the status version and runs pending status request callbacks.
   void StatusUpdated();
 
   // Runs a status request callback.
   void RunStatusCallback(const GetStatusCallback& callback) const;
 
   // Handles a status update from the source. When called with the default
   // argument values, initiates source status updates.
-  void HandleSourceStatusUpdates(
-      uint64_t version = MediaSource::kInitialStatus,
-      MediaSourceStatusPtr status = nullptr);
+  void HandleSourceStatusUpdates(uint64_t version = MediaSource::kInitialStatus,
+                                 MediaSourceStatusPtr status = nullptr);
 
   // Handles a status update from a sink. When called with the default
   // argument values, initiates sink status updates.
-  void HandleSinkStatusUpdates(
-      const std::unique_ptr<Stream>& stream,
-      uint64_t version = MediaSink::kInitialStatus,
-      MediaSinkStatusPtr status = nullptr);
+  void HandleSinkStatusUpdates(const std::unique_ptr<Stream>& stream,
+                               uint64_t version = MediaSink::kInitialStatus,
+                               MediaSinkStatusPtr status = nullptr);
 
   Event event_;
   Binding<MediaPlayer> binding_;
   MediaFactoryPtr factory_;
   MediaSourcePtr source_;
   std::vector<std::unique_ptr<Stream>> streams_;
   uint64_t status_version_ = 1u;
   bool flushed_ = true;
   MediaState reported_media_state_ = MediaState::UNPREPARED;
   Watched<MediaState> target_state_;
   Watched<int64_t> target_position_;
   TimelineTransformPtr transform_;
   MediaMetadataPtr metadata_;
   std::deque<GetStatusCallback> pending_status_requests_;
 };
 
 }  // namespace media
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_MEDIA_FACTORY_MEDIA_PLAYER_IMPL_H_