[Extenisons Bindings] Don't throw unchecked errors; add console errors

extensions/renderer/api_last_error_unittest.cc

 // Copyright 2017 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 "extensions/renderer/api_last_error.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/optional.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "gin/converter.h"
 #include "gin/public/context_holder.h"
 
 namespace extensions {
 
 namespace {
 
+void DoNothingWithError(v8::Local<v8::Context> context,
+                        const std::string& error) {}
+
 std::string GetLastError(v8::Local<v8::Object> parent,
                          v8::Local<v8::Context> context) {
   v8::Local<v8::Value> last_error =
       GetPropertyFromObject(parent, context, "lastError");
   if (last_error.IsEmpty() || !last_error->IsObject())
     return V8ToString(last_error, context);
   v8::Local<v8::Value> message =
       GetPropertyFromObject(last_error.As<v8::Object>(), context, "message");
   return V8ToString(message, context);
 }
@@ skipping 15 matching lines @@
 
 using APILastErrorTest = APIBindingTest;
 
 // Test basic functionality of the lastError object.
 TEST_F(APILastErrorTest, TestLastError) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
   v8::Local<v8::Object> parent_object = v8::Object::New(isolate());
 
   ParentList parents = {{context, parent_object}};
-  APILastError last_error(base::Bind(&GetParent, parents));
+  APILastError last_error(base::Bind(&GetParent, parents),
+                          base::Bind(&DoNothingWithError));
 
   EXPECT_EQ("undefined", GetLastError(parent_object, context));
   // Check that the key isn't present on the object (as opposed to simply being
   // undefined).
   EXPECT_FALSE(
       parent_object->Has(context, gin::StringToV8(isolate(), "lastError"))
           .ToChecked());
 
   last_error.SetError(context, "Some last error");
   EXPECT_EQ("\"Some last error\"", GetLastError(parent_object, context));
 
   last_error.ClearError(context, false);
   EXPECT_EQ("undefined", GetLastError(parent_object, context));
   EXPECT_FALSE(
       parent_object->Has(context, gin::StringToV8(isolate(), "lastError"))
           .ToChecked());
 }
 
 // Test throwing an error if the last error wasn't checked.
 TEST_F(APILastErrorTest, ReportIfUnchecked) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
   v8::Local<v8::Object> parent_object = v8::Object::New(isolate());
 
+  base::Optional<std::string> console_error;
+  auto log_error = [](base::Optional<std::string>* console_error,
+                      v8::Local<v8::Context> context,
+                      const std::string& error) { *console_error = error; };
+
   ParentList parents = {{context, parent_object}};
-  APILastError last_error(base::Bind(&GetParent, parents));
+  APILastError last_error(base::Bind(&GetParent, parents),
+                          base::Bind(log_error, &console_error));
 
   {
     v8::TryCatch try_catch(isolate());
     last_error.SetError(context, "foo");
     // GetLastError() will count as accessing the error property, so we
-    // shouldn't throw an exception.
+    // shouldn't log an error.
     EXPECT_EQ("\"foo\"", GetLastError(parent_object, context));
     last_error.ClearError(context, true);
+    EXPECT_FALSE(console_error);
     EXPECT_FALSE(try_catch.HasCaught());
   }
 
   {
     v8::TryCatch try_catch(isolate());
-    // This time, we should throw an exception.
+    // This time, we should log an error.
     last_error.SetError(context, "A last error");
     last_error.ClearError(context, true);
-    ASSERT_TRUE(try_catch.HasCaught());
-    EXPECT_EQ("Uncaught Error: A last error",
-              gin::V8ToString(try_catch.Message()->Get()));
+    ASSERT_TRUE(console_error);
+    EXPECT_EQ("Unchecked runtime.lastError: A last error", *console_error);
+    // We shouldn't have thrown an exception in order to prevent disrupting
+    // JS execution.
+    EXPECT_FALSE(try_catch.HasCaught());
   }
 }
 
 // Test behavior when something else sets a lastError property on the parent
 // object.
 TEST_F(APILastErrorTest, NonLastErrorObject) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
   v8::Local<v8::Object> parent_object = v8::Object::New(isolate());
 
   ParentList parents = {{context, parent_object}};
-  APILastError last_error(base::Bind(&GetParent, parents));
+  APILastError last_error(base::Bind(&GetParent, parents),
+                          base::Bind(&DoNothingWithError));
 
   auto checked_set = [context](v8::Local<v8::Object> object,
                                base::StringPiece key,
                                v8::Local<v8::Value> value) {
     v8::Maybe<bool> success = object->Set(
         context, gin::StringToSymbol(context->GetIsolate(), key), value);
     ASSERT_TRUE(success.IsJust());
     ASSERT_TRUE(success.FromJust());
   };
 
@@ skipping 15 matching lines @@
 
 // Test lastError in multiple different contexts.
 TEST_F(APILastErrorTest, MultipleContexts) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context_a = MainContext();
   v8::Local<v8::Context> context_b = AddContext();
 
   v8::Local<v8::Object> parent_a = v8::Object::New(isolate());
   v8::Local<v8::Object> parent_b = v8::Object::New(isolate());
   ParentList parents = {{context_a, parent_a}, {context_b, parent_b}};
-  APILastError last_error(base::Bind(&GetParent, parents));
+  APILastError last_error(base::Bind(&GetParent, parents),
+                          base::Bind(&DoNothingWithError));
 
   last_error.SetError(context_a, "Last error a");
   EXPECT_EQ("\"Last error a\"", GetLastError(parent_a, context_a));
   EXPECT_EQ("undefined", GetLastError(parent_b, context_b));
 
   last_error.SetError(context_b, "Last error b");
   EXPECT_EQ("\"Last error a\"", GetLastError(parent_a, context_a));
   EXPECT_EQ("\"Last error b\"", GetLastError(parent_b, context_b));
 
   last_error.ClearError(context_b, false);
   EXPECT_EQ("\"Last error a\"", GetLastError(parent_a, context_a));
   EXPECT_EQ("undefined", GetLastError(parent_b, context_b));
 
   last_error.ClearError(context_a, false);
   EXPECT_EQ("undefined", GetLastError(parent_a, context_a));
   EXPECT_EQ("undefined", GetLastError(parent_b, context_b));
 }
 
 }  // namespace extensions