PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/var_value_conversions.cc

 // Copyright (c) 2013 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_value_conversions.h"
 
 #include <limits>
 #include <set>
 #include <stack>
 
@@ skipping 12 matching lines @@
 #include "ppapi/shared_impl/var_tracker.h"
 
 namespace ppapi {
 
 namespace {
 
 // In CreateValueFromVar(), a stack is used to keep track of conversion progress
 // of array and dictionary vars. VarNode represents elements of that stack.
 struct VarNode {
   VarNode(const PP_Var& in_var, base::Value* in_value)
-      : var(in_var),
-        value(in_value),
-        sentinel(false) {
-  }
+      : var(in_var), value(in_value), sentinel(false) {}
 
   // This object doesn't hold a reference to it.
   PP_Var var;
   // It is not owned by this object.
   base::Value* value;
   // When this is set to true for a node in the stack, it means that we have
   // finished processing the node itself. However, we keep it in the stack as
   // a sentinel. When it becomes the top element of the stack again, we know
   // that we have processed all the descendants of this node.
   bool sentinel;
 };
 
 // In CreateVarFromValue(), a stack is used to keep track of conversion progress
 // of list and dictionary values. ValueNode represents elements of that stack.
 struct ValueNode {
   ValueNode(const PP_Var& in_var, const base::Value* in_value)
-      : var(in_var),
-        value(in_value) {
-  }
+      : var(in_var), value(in_value) {}
 
   // This object doesn't hold a reference to it.
   PP_Var var;
   // It is not owned by this object.
   const base::Value* value;
 };
 
 // Helper function for CreateValueFromVar(). It only looks at |var| but not its
 // descendants. The conversion result is stored in |value|. If |var| is array or
 // dictionary, a new node is pushed onto |state|.
@@ skipping 22 matching lines @@
       return true;
     }
     case PP_VARTYPE_STRING: {
       StringVar* string_var = StringVar::FromPPVar(var);
       if (!string_var)
         return false;
 
       value->reset(new base::StringValue(string_var->value()));
       return true;
     }
-    case PP_VARTYPE_OBJECT: {
-      return false;
-    }
+    case PP_VARTYPE_OBJECT: { return false; }
     case PP_VARTYPE_ARRAY: {
       if (ContainsKey(parent_ids, var.value.as_id)) {
         // A circular reference is found.
         return false;
       }
 
       value->reset(new base::ListValue());
       state->push(VarNode(var, value->get()));
       return true;
     }
@@ skipping 13 matching lines @@
         return false;
 
       base::BinaryValue* binary_value =
           base::BinaryValue::CreateWithCopiedBuffer(
               static_cast<const char*>(array_buffer->Map()),
               array_buffer->ByteLength());
       array_buffer->Unmap();
       value->reset(binary_value);
       return true;
     }
-    case PP_VARTYPE_RESOURCE: {
-      return false;
-    }
+    case PP_VARTYPE_RESOURCE: { return false; }
   }
   NOTREACHED();
   return false;
 }
 
 // Helper function for CreateVarFromValue(). It only looks at |value| but not
 // its descendants. The conversion result is stored in |var|. If |value| is list
 // or dictionary, a new node is pushed onto |state|.
 //
 // Returns false on failure.
@@ skipping 105 matching lines @@
                dict_var->key_value_map().begin();
            iter != dict_var->key_value_map().end();
            ++iter) {
         // Skip the key-value pair if the value is undefined or null.
         if (iter->second.get().type == PP_VARTYPE_UNDEFINED ||
             iter->second.get().type == PP_VARTYPE_NULL) {
           continue;
         }
 
         scoped_ptr<base::Value> child_value;
-        if (!CreateValueFromVarHelper(parent_ids, iter->second.get(),
-                                      &child_value, &state)) {
+        if (!CreateValueFromVarHelper(
+                 parent_ids, iter->second.get(), &child_value, &state)) {
           return NULL;
         }
 
         dict_value->SetWithoutPathExpansion(iter->first, child_value.release());
       }
     } else if (top.var.type == PP_VARTYPE_ARRAY) {
       parent_ids.insert(top.var.value.as_id);
       top.sentinel = true;
 
       ArrayVar* array_var = ArrayVar::FromPPVar(top.var);
       if (!array_var)
         return NULL;
 
       DCHECK(top.value->GetType() == base::Value::TYPE_LIST);
       base::ListValue* list_value = static_cast<base::ListValue*>(top.value);
 
       for (ArrayVar::ElementVector::const_iterator iter =
                array_var->elements().begin();
            iter != array_var->elements().end();
            ++iter) {
         scoped_ptr<base::Value> child_value;
-        if (!CreateValueFromVarHelper(parent_ids, iter->get(), &child_value,
-                                      &state)) {
+        if (!CreateValueFromVarHelper(
+                 parent_ids, iter->get(), &child_value, &state)) {
           return NULL;
         }
 
         list_value->Append(child_value.release());
       }
     } else {
       NOTREACHED();
       return NULL;
     }
   }
@@ skipping 10 matching lines @@
 
   while (!state.empty()) {
     ValueNode top = state.top();
     state.pop();
 
     if (top.value->GetType() == base::Value::TYPE_DICTIONARY) {
       const base::DictionaryValue* dict_value =
           static_cast<const base::DictionaryValue*>(top.value);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(top.var);
       DCHECK(dict_var);
-      for (base::DictionaryValue::Iterator iter(*dict_value);
-           !iter.IsAtEnd();
+      for (base::DictionaryValue::Iterator iter(*dict_value); !iter.IsAtEnd();
            iter.Advance()) {
         ScopedPPVar child_var;
         if (!CreateVarFromValueHelper(iter.value(), &child_var, &state) ||
             !dict_var->SetWithStringKey(iter.key(), child_var.get())) {
           return PP_MakeUndefined();
         }
       }
     } else if (top.value->GetType() == base::Value::TYPE_LIST) {
       const base::ListValue* list_value =
           static_cast<const base::ListValue*>(top.value);
@@ skipping 10 matching lines @@
       }
     } else {
       NOTREACHED();
       return PP_MakeUndefined();
     }
   }
 
   return root_var.Release();
 }
 
-base::ListValue* CreateListValueFromVarVector(
-    const std::vector<PP_Var>& vars) {
+base::ListValue* CreateListValueFromVarVector(const std::vector<PP_Var>& vars) {
   scoped_ptr<base::ListValue> list_value(new base::ListValue());
 
   for (std::vector<PP_Var>::const_iterator iter = vars.begin();
        iter != vars.end();
        ++iter) {
     base::Value* value = CreateValueFromVar(*iter);
     if (!value)
       return NULL;
     list_value->Append(value);
   }
   return list_value.release();
 }
 
 bool CreateVarVectorFromListValue(const base::ListValue& list_value,
                                   std::vector<PP_Var>* vars) {
   if (!vars)
     return false;
 
   std::vector<ScopedPPVar> result;
   result.reserve(list_value.GetSize());
   for (base::ListValue::const_iterator iter = list_value.begin();
        iter != list_value.end();
        ++iter) {
-    ScopedPPVar child_var(ScopedPPVar::PassRef(),
-                          CreateVarFromValue(**iter));
+    ScopedPPVar child_var(ScopedPPVar::PassRef(), CreateVarFromValue(**iter));
     if (child_var.get().type == PP_VARTYPE_UNDEFINED)
       return false;
 
     result.push_back(child_var);
   }
 
   vars->clear();
   vars->reserve(result.size());
   for (std::vector<ScopedPPVar>::iterator iter = result.begin();
        iter != result.end();
        ++iter) {
     vars->push_back(iter->Release());
   }
 
   return true;
 }
 
 }  // namespace ppapi
-