Motown: wholesale clang-format

services/media/framework_mojo/mojo_consumer.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_CONSUMER_H_
 #define SERVICES_MEDIA_FRAMEWORK_MOJO_MOJO_CONSUMER_H_
 
-
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "mojo/common/binding_set.h"
 #include "mojo/services/media/common/cpp/mapped_shared_buffer.h"
 #include "mojo/services/media/common/interfaces/media_transport.mojom.h"
 #include "services/media/framework/models/active_source.h"
 
 namespace mojo {
 namespace media {
 
@@ skipping 24 matching lines @@
 
   // Sets a callback signalling that a prime has been requested from the
   // MediaConsumer client.
   void SetPrimeRequestedCallback(const PrimeRequestedCallback& callback);
 
   // Sets a callback signalling that a flush has been requested from the
   // MediaConsumer client.
   void SetFlushRequestedCallback(const FlushRequestedCallback& callback);
 
   // MediaConsumer implementation.
-  void SetBuffer(
-      ScopedSharedBufferHandle buffer,
-      const SetBufferCallback& callback) override;
+  void SetBuffer(ScopedSharedBufferHandle buffer,
+                 const SetBufferCallback& callback) override;
 
-  void SendPacket(MediaPacketPtr packet, const SendPacketCallback& callback)
-      override;
+  void SendPacket(MediaPacketPtr packet,
+                  const SendPacketCallback& callback) override;
 
   void Prime(const PrimeCallback& callback) override;
 
   void MediaConsumerFlush(const FlushCallback& callback) override;
 
   // ActiveSource implementation.
   bool can_accept_allocator() const override;
 
   void set_allocator(PayloadAllocator* allocator) override;
 
   void SetSupplyCallback(const SupplyCallback& supply_callback) override;
 
   void SetDownstreamDemand(Demand demand) override;
 
  private:
   MojoConsumer();
 
   // Specialized packet implementation.
   class PacketImpl : public Packet {
    public:
     static PacketPtr Create(
         MediaPacketPtr media_packet,
         const SendPacketCallback& callback,
         scoped_refptr<base::SingleThreadTaskRunner> task_runner,
         const MappedSharedBuffer& buffer) {
-      return PacketPtr(new PacketImpl(
-          media_packet.Pass(),
-          callback,
-          task_runner,
-          buffer));
+      return PacketPtr(
+          new PacketImpl(media_packet.Pass(), callback, task_runner, buffer));
     }
 
    protected:
     void Release() override;
 
    private:
-    PacketImpl(
-        MediaPacketPtr media_packet,
-        const SendPacketCallback& callback,
-        scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-        const MappedSharedBuffer& buffer);
+    PacketImpl(MediaPacketPtr media_packet,
+               const SendPacketCallback& callback,
+               scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+               const MappedSharedBuffer& buffer);
 
     ~PacketImpl() override;
 
     static void RunCallback(const SendPacketCallback& callback);
 
     MediaPacketPtr media_packet_;
     const SendPacketCallback callback_;
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   };
 
   BindingSet<MediaConsumer> bindings_;
   PrimeRequestedCallback prime_requested_callback_;
   FlushRequestedCallback flush_requested_callback_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   MappedSharedBuffer buffer_;
   SupplyCallback supply_callback_;
 };
 
 }  // namespace media
 }  // namespace mojo
 
 #endif  // SERVICES_MEDIA_FRAMEWORK_MOJO_MOJO_CONSUMER_H_