PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/v8_var_converter_unittest.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 "content/renderer/pepper/v8_var_converter.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 64 matching lines @@
       return it->second == val;
     (*visited_ids)[var.value.as_id] = val;
   }
 
   if (val->IsUndefined()) {
     return var.type == PP_VARTYPE_UNDEFINED;
   } else if (val->IsNull()) {
     return var.type == PP_VARTYPE_NULL;
   } else if (val->IsBoolean() || val->IsBooleanObject()) {
     return var.type == PP_VARTYPE_BOOL &&
-        PP_FromBool(val->ToBoolean()->Value()) == var.value.as_bool;
+           PP_FromBool(val->ToBoolean()->Value()) == var.value.as_bool;
   } else if (val->IsInt32()) {
     return var.type == PP_VARTYPE_INT32 &&
-        val->ToInt32()->Value() == var.value.as_int;
+           val->ToInt32()->Value() == var.value.as_int;
   } else if (val->IsNumber() || val->IsNumberObject()) {
     return var.type == PP_VARTYPE_DOUBLE &&
-        fabs(val->ToNumber()->Value() - var.value.as_double) <= 1.0e-4;
+           fabs(val->ToNumber()->Value() - var.value.as_double) <= 1.0e-4;
   } else if (val->IsString() || val->IsStringObject()) {
     if (var.type != PP_VARTYPE_STRING)
       return false;
     StringVar* string_var = StringVar::FromPPVar(var);
     DCHECK(string_var);
     v8::String::Utf8Value utf8(val->ToString());
     return std::string(*utf8, utf8.length()) == string_var->value();
   } else if (val->IsArray()) {
     if (var.type != PP_VARTYPE_ARRAY)
       return false;
@@ skipping 24 matching lines @@
         return false;
       for (uint32 i = 0; i < property_names->Length(); ++i) {
         v8::Handle<v8::Value> key(property_names->Get(i));
 
         if (!key->IsString() && !key->IsNumber())
           return false;
         v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
 
         v8::String::Utf8Value name_utf8(key->ToString());
         ScopedPPVar release_key(ScopedPPVar::PassRef(),
-            StringVar::StringToPPVar(
-                std::string(*name_utf8, name_utf8.length())));
+                                StringVar::StringToPPVar(std::string(
+                                    *name_utf8, name_utf8.length())));
         if (!dict_var->HasKey(release_key.get()))
           return false;
         ScopedPPVar release_value(ScopedPPVar::PassRef(),
                                   dict_var->Get(release_key.get()));
         if (!Equals(release_value.get(), child_v8, visited_ids))
           return false;
       }
       return true;
     }
   }
   return false;
 }
 
-bool Equals(const PP_Var& var,
-            v8::Handle<v8::Value> val) {
+bool Equals(const PP_Var& var, v8::Handle<v8::Value> val) {
   VarHandleMap var_handle_map;
   return Equals(var, val, &var_handle_map);
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
   V8VarConverterTest()
-      : isolate_(v8::Isolate::GetCurrent()),
-        conversion_success_(false) {
+      : isolate_(v8::Isolate::GetCurrent()), conversion_success_(false) {
     PP_Instance dummy = 1234;
     converter_.reset(new V8VarConverter(
         dummy,
         scoped_ptr<ResourceConverter>(new MockResourceConverter).Pass()));
   }
   virtual ~V8VarConverterTest() {}
 
   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::Acquire();
     v8::HandleScope handle_scope(isolate_);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
     context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
   }
   virtual void TearDown() {
     context_.Reset();
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  protected:
   bool FromV8ValueSync(v8::Handle<v8::Value> val,
                        v8::Handle<v8::Context> context,
                        PP_Var* result) {
     base::RunLoop loop;
-    converter_->FromV8Value(val, context, base::Bind(
-        &V8VarConverterTest::FromV8ValueComplete, base::Unretained(this),
-        loop.QuitClosure()));
+    converter_->FromV8Value(val,
+                            context,
+                            base::Bind(&V8VarConverterTest::FromV8ValueComplete,
+                                       base::Unretained(this),
+                                       loop.QuitClosure()));
     loop.Run();
     if (conversion_success_)
       *result = conversion_result_;
     return conversion_success_;
   }
 
   void FromV8ValueComplete(base::Closure quit_closure,
                            const ScopedPPVar& scoped_var,
                            bool success) {
     conversion_success_ = success;
@@ skipping 74 matching lines @@
 
   // Array with primitives.
   array->Set(index++, PP_MakeUndefined());
   array->Set(index++, PP_MakeNull());
   array->Set(index++, PP_MakeInt32(100));
   array->Set(index++, PP_MakeBool(PP_FALSE));
   array->Set(index++, PP_MakeDouble(0.123));
   EXPECT_TRUE(RoundTripAndCompare(array->GetPPVar()));
 
   // Array with 2 references to the same string.
-  ScopedPPVar release_string(
-      ScopedPPVar::PassRef(), StringVar::StringToPPVar("abc"));
+  ScopedPPVar release_string(ScopedPPVar::PassRef(),
+                             StringVar::StringToPPVar("abc"));
   array->Set(index++, release_string.get());
   array->Set(index++, release_string.get());
   EXPECT_TRUE(RoundTripAndCompare(array->GetPPVar()));
 
   // Array with nested array that references the same string.
   scoped_refptr<ArrayVar> array2(new ArrayVar);
   ScopedPPVar release_array2(ScopedPPVar::PassRef(), array2->GetPPVar());
   array2->Set(0, release_string.get());
   array->Set(index++, release_array2.get());
   EXPECT_TRUE(RoundTripAndCompare(array->GetPPVar()));
@@ skipping 50 matching lines @@
     scoped_refptr<ArrayVar> array(new ArrayVar);
     ScopedPPVar release_array(ScopedPPVar::PassRef(), array->GetPPVar());
 
     dictionary->SetWithStringKey("1", release_array.get());
     array->Set(0, release_dictionary.get());
 
     v8::Handle<v8::Value> v8_result;
 
     // Array <-> dictionary cycle.
     dictionary->SetWithStringKey("1", release_array.get());
-    ASSERT_FALSE(converter_->ToV8Value(release_dictionary.get(),
-                                       context, &v8_result));
+    ASSERT_FALSE(
+        converter_->ToV8Value(release_dictionary.get(), context, &v8_result));
     // Break the cycle.
     // TODO(raymes): We need some better machinery for releasing vars with
     // cycles. Remove the code below once we have that.
     dictionary->DeleteWithStringKey("1");
 
     // Array with self reference.
     array->Set(0, release_array.get());
-    ASSERT_FALSE(converter_->ToV8Value(release_array.get(),
-                                       context, &v8_result));
+    ASSERT_FALSE(
+        converter_->ToV8Value(release_array.get(), context, &v8_result));
     // Break the self reference.
     array->Set(0, PP_MakeUndefined());
   }
 
   // V8->Var conversion.
   {
     v8::Handle<v8::Object> object = v8::Object::New(isolate_);
     v8::Handle<v8::Array> array = v8::Array::New(isolate_);
 
     PP_Var var_result;
@@ skipping 23 matching lines @@
     EXPECT_TRUE(RoundTripAndCompare(dictionary->GetPPVar()));
   }
 
   {
     // Test non-string key types. They should be cast to strings.
     v8::HandleScope handle_scope(isolate_);
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, context_);
     v8::Context::Scope context_scope(context);
 
-    const char* source = "(function() {"
+    const char* source =
+        "(function() {"
         "return {"
-          "1: 'foo',"
-          "'2': 'bar',"
-          "true: 'baz',"
-          "false: 'qux',"
-          "null: 'quux',"
-          "undefined: 'oops'"
+        "1: 'foo',"
+        "'2': 'bar',"
+        "true: 'baz',"
+        "false: 'qux',"
+        "null: 'quux',"
+        "undefined: 'oops'"
         "};"
         "})();";
 
     v8::Handle<v8::Script> script(
         v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
     v8::Handle<v8::Object> object = script->Run().As<v8::Object>();
     ASSERT_FALSE(object.IsEmpty());
 
     PP_Var actual;
-    ASSERT_TRUE(FromV8ValueSync(object,
-        v8::Local<v8::Context>::New(isolate_, context_), &actual));
+    ASSERT_TRUE(FromV8ValueSync(
+        object, v8::Local<v8::Context>::New(isolate_, context_), &actual));
     ScopedPPVar release_actual(ScopedPPVar::PassRef(), actual);
 
     scoped_refptr<DictionaryVar> expected(new DictionaryVar);
     ScopedPPVar foo(ScopedPPVar::PassRef(), StringVar::StringToPPVar("foo"));
     expected->SetWithStringKey("1", foo.get());
     ScopedPPVar bar(ScopedPPVar::PassRef(), StringVar::StringToPPVar("bar"));
     expected->SetWithStringKey("2", bar.get());
     ScopedPPVar baz(ScopedPPVar::PassRef(), StringVar::StringToPPVar("baz"));
     expected->SetWithStringKey("true", baz.get());
     ScopedPPVar qux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("qux"));
     expected->SetWithStringKey("false", qux.get());
     ScopedPPVar quux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("quux"));
     expected->SetWithStringKey("null", quux.get());
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
-    ScopedPPVar release_expected(
-        ScopedPPVar::PassRef(), expected->GetPPVar());
+    ScopedPPVar release_expected(ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get(), true));
   }
 }
 
 }  // namespace content