PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/var_tracker.cc

 // 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.
 
 #include "ppapi/shared_impl/var_tracker.h"
 
 #include <string.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "ppapi/shared_impl/host_resource.h"
 #include "ppapi/shared_impl/id_assignment.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource_var.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 
 VarTracker::VarInfo::VarInfo()
-    : var(),
-      ref_count(0),
-      track_with_no_reference_count(0) {
-}
+    : var(), ref_count(0), track_with_no_reference_count(0) {}
 
 VarTracker::VarInfo::VarInfo(Var* v, int input_ref_count)
-    : var(v),
-      ref_count(input_ref_count),
-      track_with_no_reference_count(0) {
-}
+    : var(v), ref_count(input_ref_count), track_with_no_reference_count(0) {}
 
 VarTracker::VarTracker(ThreadMode thread_mode) : last_var_id_(0) {
   if (thread_mode == SINGLE_THREADED)
     thread_checker_.reset(new base::ThreadChecker);
 }
 
-VarTracker::~VarTracker() {
-}
+VarTracker::~VarTracker() {}
 
 void VarTracker::CheckThreadingPreconditions() const {
   DCHECK(!thread_checker_ || thread_checker_->CalledOnValidThread());
 #ifndef NDEBUG
   ProxyLock::AssertAcquired();
 #endif
 }
 
 int32 VarTracker::AddVar(Var* var) {
   CheckThreadingPreconditions();
@@ skipping 94 matching lines @@
   return ReleaseVar(static_cast<int32>(var.value.as_id));
 }
 
 int32 VarTracker::AddVarInternal(Var* var, AddVarRefMode mode) {
   // If the plugin manages to create millions of strings.
   if (last_var_id_ == std::numeric_limits<int32>::max() >> kPPIdTypeBits)
     return 0;
 
   int32 new_id = MakeTypedId(++last_var_id_, PP_ID_TYPE_VAR);
   std::pair<VarMap::iterator, bool> was_inserted =
-      live_vars_.insert(std::make_pair(new_id,
-          VarInfo(var, mode == ADD_VAR_TAKE_ONE_REFERENCE ? 1 : 0)));
+      live_vars_.insert(std::make_pair(
+          new_id, VarInfo(var, mode == ADD_VAR_TAKE_ONE_REFERENCE ? 1 : 0)));
   // We should never insert an ID that already exists.
   DCHECK(was_inserted.second);
 
   return new_id;
 }
 
 VarTracker::VarMap::iterator VarTracker::GetLiveVar(int32 id) {
   return live_vars_.find(id);
 }
 
@@ skipping 18 matching lines @@
 
 // static
 bool VarTracker::IsVarTypeRefcounted(PP_VarType type) {
   return type >= PP_VARTYPE_STRING;
 }
 
 VarTracker::VarMap::iterator VarTracker::GetLiveVar(const PP_Var& var) {
   return live_vars_.find(static_cast<int32>(var.value.as_id));
 }
 
-VarTracker::VarMap::const_iterator VarTracker::GetLiveVar(
-    const PP_Var& var) const {
+VarTracker::VarMap::const_iterator VarTracker::GetLiveVar(const PP_Var& var)
+    const {
   return live_vars_.find(static_cast<int32>(var.value.as_id));
 }
 
 PP_Var VarTracker::MakeArrayBufferPPVar(uint32 size_in_bytes) {
   CheckThreadingPreconditions();
 
   scoped_refptr<ArrayBufferVar> array_buffer(CreateArrayBuffer(size_in_bytes));
   if (!array_buffer.get())
     return PP_MakeNull();
   return array_buffer->GetPPVar();
@@ skipping 61 matching lines @@
 bool VarTracker::DeleteObjectInfoIfNecessary(VarMap::iterator iter) {
   if (iter->second.ref_count != 0 ||
       iter->second.track_with_no_reference_count != 0)
     return false;  // Object still alive.
   iter->second.var->ResetVarID();
   live_vars_.erase(iter);
   return true;
 }
 
 }  // namespace ppapi