Motown: wholesale clang-format

services/media/framework_mojo/mojo_pull_mode_producer.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 SERVICES_MEDIA_FRAMEWORK_MOJO_MOJO_PULL_MODE_PRODUCER_H_
 #define SERVICES_MEDIA_FRAMEWORK_MOJO_MOJO_PULL_MODE_PRODUCER_H_
 
 #include <deque>
 
 #include "base/synchronization/lock.h"
 #include "mojo/common/binding_set.h"
 #include "mojo/services/media/common/interfaces/media_state.mojom.h"
 #include "mojo/services/media/common/interfaces/media_transport.mojom.h"
 #include "services/media/framework/models/active_sink.h"
 #include "services/media/framework_mojo/mojo_allocator.h"
 
 namespace mojo {
 namespace media {
 
 // Implements MediaPullModeProducer to forward a stream across mojo.
-class MojoPullModeProducer :
-    public MediaPullModeProducer,
-    public ActiveSink {
+class MojoPullModeProducer : public MediaPullModeProducer, public ActiveSink {
  public:
   static std::shared_ptr<MojoPullModeProducer> Create() {
     return std::shared_ptr<MojoPullModeProducer>(new MojoPullModeProducer());
   }
 
   ~MojoPullModeProducer() override;
 
   // Adds a binding.
   void AddBinding(InterfaceRequest<MediaPullModeProducer> producer);
 
   // MediaPullModeProducer implementation.
   void GetBuffer(const GetBufferCallback& callback) override;
 
-  void PullPacket(
-      MediaPacketPtr to_release,
-      const PullPacketCallback& callback) override;
+  void PullPacket(MediaPacketPtr to_release,
+                  const PullPacketCallback& callback) override;
 
   void ReleasePacket(MediaPacketPtr to_release) override;
 
   // ActiveSink implementation.
   PayloadAllocator* allocator() override;
 
   void SetDemandCallback(const DemandCallback& demand_callback) override;
 
   Demand SupplyPacket(PacketPtr packet) override;
 
  private:
   MojoPullModeProducer();
 
   // Handles as many pending pulls as possible.
   // MUST BE CALLED WITH lock_ TAKEN.
   void HandlePendingPullsUnsafe();
 
   // Attempts to handle a pull and indicates whether it was handled.
   // MUST BE CALLED WITH lock_ TAKEN.
   bool MaybeHandlePullUnsafe(const PullPacketCallback& callback);
 
   // Runs the callback with a new MediaPacket created from the given Packet.
   // MUST BE CALLED WITH lock_ TAKEN.
-  void HandlePullWithPacketUnsafe(
-      const PullPacketCallback& callback,
-      PacketPtr packet);
+  void HandlePullWithPacketUnsafe(const PullPacketCallback& callback,
+                                  PacketPtr packet);
 
   // Creates a MediaPacket from a Packet.
   MediaPacketPtr CreateMediaPacket(const PacketPtr& packet);
 
   BindingSet<MediaPullModeProducer> bindings_;
 
   DemandCallback demand_callback_;
 
   // Allocates from the shared buffer.
   MojoAllocator mojo_allocator_;
@@ skipping 14 matching lines @@
   std::deque<PullPacketCallback> pending_pulls_;
   std::deque<PacketPtr> unreleased_packets_;
   PacketPtr cached_packet_;
   // THE FIELDS ABOVE SHOULD ONLY BE ACCESSED WITH lock_ TAKEN.
 };
 
 }  // namespace media
 }  // namespace mojo
 
 #endif  // SERVICES_MEDIA_FRAMEWORK_MOJO_MOJO_PULL_MODE_PRODUCER_H_