PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/var_value_conversions_unittest.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 <cmath>
 #include <cstring>
 
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 namespace ppapi {
 namespace {
 
 bool Equals(const base::Value& value, const PP_Var& var) {
   switch (value.GetType()) {
     case base::Value::TYPE_NULL: {
       return var.type == PP_VARTYPE_NULL || var.type == PP_VARTYPE_UNDEFINED;
     }
     case base::Value::TYPE_BOOLEAN: {
       bool result = false;
-      return var.type == PP_VARTYPE_BOOL &&
-             value.GetAsBoolean(&result) &&
+      return var.type == PP_VARTYPE_BOOL && value.GetAsBoolean(&result) &&
              result == PP_ToBool(var.value.as_bool);
     }
     case base::Value::TYPE_INTEGER: {
       int result = 0;
-      return var.type == PP_VARTYPE_INT32 &&
-             value.GetAsInteger(&result) &&
+      return var.type == PP_VARTYPE_INT32 && value.GetAsInteger(&result) &&
              result == var.value.as_int;
     }
     case base::Value::TYPE_DOUBLE: {
       double result = 0;
-      return var.type == PP_VARTYPE_DOUBLE &&
-             value.GetAsDouble(&result) &&
+      return var.type == PP_VARTYPE_DOUBLE && value.GetAsDouble(&result) &&
              fabs(result - var.value.as_double) < 1.0e-4;
     }
     case base::Value::TYPE_STRING: {
       std::string result;
       StringVar* string_var = StringVar::FromPPVar(var);
-      return string_var &&
-             value.GetAsString(&result) &&
+      return string_var && value.GetAsString(&result) &&
              result == string_var->value();
     }
     case base::Value::TYPE_BINARY: {
       const base::BinaryValue& binary_value =
           static_cast<const base::BinaryValue&>(value);
       ArrayBufferVar* array_buffer_var = ArrayBufferVar::FromPPVar(var);
       if (!array_buffer_var ||
           binary_value.GetSize() != array_buffer_var->ByteLength()) {
         return false;
       }
 
-      bool result = !memcmp(binary_value.GetBuffer(), array_buffer_var->Map(),
+      bool result = !memcmp(binary_value.GetBuffer(),
+                            array_buffer_var->Map(),
                             binary_value.GetSize());
       array_buffer_var->Unmap();
       return result;
     }
     case base::Value::TYPE_DICTIONARY: {
       const base::DictionaryValue& dict_value =
           static_cast<const base::DictionaryValue&>(value);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
       if (!dict_var)
         return false;
@@ skipping 49 matching lines @@
 
 bool ConvertValueAndVerify(const base::Value& value) {
   ScopedPPVar var(ScopedPPVar::PassRef(), CreateVarFromValue(value));
   if (var.get().type != PP_VARTYPE_UNDEFINED)
     return Equals(value, var.get());
   return false;
 }
 
 class VarValueConversionsTest : public testing::Test {
  public:
-  VarValueConversionsTest() {
-  }
-  virtual ~VarValueConversionsTest() {
-  }
+  VarValueConversionsTest() {}
+  virtual ~VarValueConversionsTest() {}
 
   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::EnableLockingOnThreadForTest();
     ProxyLock::Acquire();
   }
   virtual void TearDown() {
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
@@ skipping 83 matching lines @@
     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
     scoped_refptr<ArrayVar> array_var(new ArrayVar());
     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 
     ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull()));
-    ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key",
-                                             string_pp_var.get()));
+    ASSERT_TRUE(
+        dict_var_1->SetWithStringKey("string_key", string_pp_var.get()));
     ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get()));
 
-    ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key",
-                                             PP_MakeUndefined()));
+    ASSERT_TRUE(
+        dict_var_2->SetWithStringKey("undefined_key", PP_MakeUndefined()));
     ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1)));
     ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get()));
 
     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
     ASSERT_TRUE(array_var->SetLength(4));
 
     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
   }
 
@@ skipping 126 matching lines @@
       const base::Value* value = NULL;
       ASSERT_TRUE(list_value.Get(i, &value));
       ASSERT_TRUE(Equals(*value, vars[i]));
 
       PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]);
     }
   }
 }
 
 }  // namespace ppapi