Use PASS() everywhere in ppapi/tests.

ppapi/tests/test_var_deprecated.cc

 // Copyright (c) 2010 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/tests/test_var_deprecated.h"
 
 #include <string.h>
 
 #include <limits>
 
@@ skipping 55 matching lines @@
     var_interface_->Release(str);
     result = var_interface_->VarToUtf8(str, &len);
     ASSERT_EQ(0, len);
     ASSERT_EQ(NULL, result);
   }
 
   // Make sure nothing leaked.
   ASSERT_TRUE(testing_interface_->GetLiveObjectCount(
       pp::Module::Get()->pp_module()) == before_object);
 
-  return std::string();
+  PASS();
 }
 
 std::string TestVarDeprecated::TestInvalidAndEmpty() {
   PP_Var invalid_string;
   invalid_string.type = PP_VARTYPE_STRING;
   invalid_string.value.as_id = 31415926;
 
   // Invalid strings should give NULL as the return value.
   uint32_t len = std::numeric_limits<uint32_t>::max();
   const char* result = var_interface_->VarToUtf8(invalid_string, &len);
   ASSERT_EQ(0, len);
   ASSERT_EQ(NULL, result);
 
   // Same with vars that are not strings.
   len = std::numeric_limits<uint32_t>::max();
   pp::Var int_var(42);
   result = var_interface_->VarToUtf8(int_var.pp_var(), &len);
   ASSERT_EQ(0, len);
   ASSERT_EQ(NULL, result);
 
   // Empty strings should return non-NULL.
   pp::Var empty_string("");
   len = std::numeric_limits<uint32_t>::max();
   result = var_interface_->VarToUtf8(empty_string.pp_var(), &len);
   ASSERT_EQ(0, len);
   ASSERT_NE(NULL, result);
 
-  return std::string();
+  PASS();
 }
 
 std::string TestVarDeprecated::TestInvalidUtf8() {
   // utf8じゃない (japanese for "is not utf8") in shift-jis encoding.
   static const char kSjisString[] = "utf8\x82\xb6\x82\xe1\x82\xc8\x82\xa2";
   pp::Var sjis(kSjisString);
   if (!sjis.is_null())
     return "Non-UTF8 string permitted.";
 
-  return "";
+  PASS();
 }
 
 std::string TestVarDeprecated::TestNullInputInUtf8Conversion() {
   // This test talks directly to the C interface to access edge cases that
   // cannot be exercised via the C++ interface.
   PP_Var converted_string;
 
   // 0-length string should not dereference input string, and should produce
   // an empty string.
   converted_string = var_interface_->VarFromUtf8(
@@ skipping 13 matching lines @@
     return "Expected a non-null result for 0-lengthed string from VarToUtf8.";
   }
 
   // Should not crash, and make an empty string.
   const char* null_string = NULL;
   pp::Var null_var(null_string);
   if (!null_var.is_string() || null_var.AsString() != "") {
     return "Expected NULL input to make an empty string Var.";
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestVarDeprecated::TestValidUtf8() {
   // From UTF8 string -> PP_Var.
   // Chinese for "I am utf8."
   static const char kValidUtf8[] = "\xe6\x88\x91\xe6\x98\xafutf8.";
   pp::Var converted_string(kValidUtf8);
 
   if (converted_string.is_null())
     return "Unable to convert valid utf8 to var.";
 
   // Since we're already here, test PP_Var back to UTF8 string.
   std::string returned_string = converted_string.AsString();
 
   // We need to check against 1 less than sizeof because the resulting string
   // is technically not NULL terminated by API design.
   if (returned_string.size() != sizeof(kValidUtf8) - 1) {
     return "Unable to convert utf8 string back from var.";
   }
   if (returned_string != kValidUtf8) {
     return "String mismatches on conversion back from PP_Var.";
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestVarDeprecated::TestUtf8WithEmbeddedNulls() {
   // From UTF8 string with embedded nulls -> PP_Var.
   // Chinese for "also utf8."
   static const char kUtf8WithEmbededNull[] = "\xe6\xb9\x9f\xe6\x98\xaf\0utf8.";
   std::string orig_string(kUtf8WithEmbededNull,
                           sizeof(kUtf8WithEmbededNull) -1);
   pp::Var converted_string(orig_string);
 
   if (converted_string.is_null())
     return "Unable to convert utf8 with embedded nulls to var.";
 
   // Since we're already here, test PP_Var back to UTF8 string.
   std::string returned_string = converted_string.AsString();
 
   if (returned_string.size() != orig_string.size()) {
     return "Unable to convert utf8 with embedded nulls back from var.";
   }
   if (returned_string != orig_string) {
     return "String mismatches on conversion back from PP_Var.";
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestVarDeprecated::TestVarToUtf8ForWrongType() {
   uint32_t length = kInvalidLength;
   const char* result = NULL;
   result = var_interface_->VarToUtf8(PP_MakeUndefined(), &length);
   if (length != 0) {
     return "Expected 0 on string conversion from Void var.";
   }
   if (result != NULL) {
@@ skipping 33 matching lines @@
   length = kInvalidLength;
   result = NULL;
   result = var_interface_->VarToUtf8(PP_MakeDouble(1.0), &length);
   if (length != 0) {
     return "Expected 0 on string conversion from Double var.";
   }
   if (result != NULL) {
     return "Expected NULL on string conversion from Double var.";
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestVarDeprecated::TestHasPropertyAndMethod() {
   uint32_t before_objects = testing_interface_->GetLiveObjectCount(
       pp::Module::Get()->pp_module());
   {
     pp::Var window = instance_->GetWindowObject();
     ASSERT_TRUE(window.is_object());
 
     // Regular property.
@@ skipping 56 matching lines @@
     ASSERT_FALSE(window.HasProperty("find", &exception));
     ASSERT_FALSE(exception.is_undefined());
     ASSERT_FALSE(window.HasMethod("find", &exception));
     ASSERT_FALSE(exception.is_undefined());
   }
 
   // Make sure nothing leaked.
   ASSERT_TRUE(testing_interface_->GetLiveObjectCount(
       pp::Module::Get()->pp_module()) == before_objects);
 
-  return std::string();
+  PASS();
 }