PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/array_writer.h

 // Copyright (c) 2012 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 PPAPI_SHARED_IMPL_ARRAY_WRITER_H_
 #define PPAPI_SHARED_IMPL_ARRAY_WRITER_H_
 
 #include <string.h>
 
 #include <vector>
@@ skipping 36 matching lines @@
   // call since one output function should only be issued once.
   //
   // THIS IS DESIGNED FOR POD ONLY. For the case of resources, for example, we
   // want to transfer a reference only on success. Likewise, if you have a
   // structure of PP_Vars or a struct that contains a PP_Resource, we need to
   // make sure that the right thing happens with the ref on success and failure.
   template <typename T>
   bool StoreArray(const T* input, uint32_t count) {
     // Always call the alloc function, even on 0 array size.
     void* dest = pp_array_output_.GetDataBuffer(
-        pp_array_output_.user_data,
-        count,
-        sizeof(T));
+        pp_array_output_.user_data, count, sizeof(T));
 
     // Regardless of success, we clear the output to prevent future calls on
     // this same output object.
     Reset();
 
     if (count == 0)
       return true;  // Allow plugin to return NULL on 0 elements.
     if (!dest)
       return false;
 
     if (input)
       memcpy(dest, input, sizeof(T) * count);
     return true;
   }
 
   // Copies the given array/vector of data to the plugin output array.  See
   // comment of StoreArray() for detail.
-  template<typename T>
+  template <typename T>
   bool StoreVector(const std::vector<T>& input) {
     return StoreArray(input.size() ? &input[0] : NULL, input.size());
   }
 
   // Stores the given vector of resources as PP_Resources to the output vector,
   // adding one reference to each.
   //
   // On failure this returns false, nothing will be copied, and the resource
   // refcounts will be unchanged. In either case, the object will become
   // is_null() immediately after the call since one output function should only
   // be issued once.
   //
   // Note: potentially this could be a template in case you have a vector of
   // FileRef objects, for example. However, this saves code since there's only
   // one instantiation and is sufficient for now.
-  bool StoreResourceVector(const std::vector< scoped_refptr<Resource> >& input);
+  bool StoreResourceVector(const std::vector<scoped_refptr<Resource> >& input);
 
   // Like the above version but takes an array of AddRef'ed PP_Resources. On
   // storage failure, this will release each resource.
   bool StoreResourceVector(const std::vector<PP_Resource>& input);
 
   // Stores the given vector of vars as PP_Vars to the output vector,
   // adding one reference to each.
   //
   // On failure this returns false, nothing will be copied, and the var
   // refcounts will be unchanged. In either case, the object will become
   // is_null() immediately after the call since one output function should only
   // be issued once.
-  bool StoreVarVector(const std::vector< scoped_refptr<Var> >& input);
+  bool StoreVarVector(const std::vector<scoped_refptr<Var> >& input);
 
   // Like the above version but takes an array of AddRef'ed PP_Vars. On
   // storage failure, this will release each var.
   bool StoreVarVector(const std::vector<PP_Var>& input);
 
  private:
   PP_ArrayOutput pp_array_output_;
 
   DISALLOW_COPY_AND_ASSIGN(ArrayWriter);
 };
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_ARRAY_WRITER_H_