Adding checks for V8 functions returning Maybe<bool>

extensions/renderer/module_system.cc

 // Copyright 2014 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/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 476 matching lines @@
 
   // Ok for it to be undefined, among other things it's how bindings signify
   // that the extension doesn't have permission to use them.
   CHECK(!new_field.IsEmpty());
 
   // Delete the getter and set this field to |new_field| so the same object is
   // returned every time a certain API is accessed.
   v8::Local<v8::Value> val = info.This();
   if (val->IsObject()) {
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(val);
-    object->Delete(context, property);
+    auto maybe = object->Delete(context, property);
+    CHECK(IsTrue(maybe));
     SetProperty(context, object, property, new_field);
   } else {
     NOTREACHED();
   }
   info.GetReturnValue().Set(new_field);
 
   UMA_HISTOGRAM_TIMES("Extensions.ApiBindingGenerationTime", timer.Elapsed());
 }
 
 void ModuleSystem::SetLazyField(v8::Local<v8::Object> object,
@@ skipping 113 matching lines @@
   v8::Local<v8::Context> v8_context = context_->v8_context();
   v8::Local<v8::Promise::Resolver> resolver(
       v8::Promise::Resolver::New(v8_context).ToLocalChecked());
   args.GetReturnValue().Set(resolver->GetPromise());
   std::unique_ptr<v8::Global<v8::Promise::Resolver>> global_resolver(
       new v8::Global<v8::Promise::Resolver>(GetIsolate(), resolver));
   gin::ModuleRegistry* module_registry =
       gin::ModuleRegistry::From(v8_context);
   if (!module_registry) {
     Warn(GetIsolate(), "Extension view no longer exists");
-    resolver->Reject(v8_context, v8::Exception::Error(ToV8StringUnsafe(
-        GetIsolate(), "Extension view no longer exists")));
+    auto maybe = resolver->Reject(
+        v8_context,
+        v8::Exception::Error(ToV8StringUnsafe(
+            GetIsolate(),
+            "Extension view no longer exists")));
+    CHECK(IsTrue(maybe));
     return;
   }
   module_registry->LoadModule(
       GetIsolate(), module_name,
       base::Bind(&ModuleSystem::OnModuleLoaded, weak_factory_.GetWeakPtr(),
                  base::Passed(&global_resolver)));
   if (module_registry->available_modules().count(module_name) == 0)
     LoadModule(module_name);
 }
 
@@ skipping 185 matching lines @@
 }
 
 void ModuleSystem::OnModuleLoaded(
     std::unique_ptr<v8::Global<v8::Promise::Resolver>> resolver,
     v8::Local<v8::Value> value) {
   if (!is_valid())
     return;
   v8::HandleScope handle_scope(GetIsolate());
   v8::Local<v8::Promise::Resolver> resolver_local(
       v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
-  resolver_local->Resolve(context()->v8_context(), value);
+  auto maybe = resolver_local->Resolve(context()->v8_context(), value);
+  CHECK(IsTrue(maybe));
 }
 
 void ModuleSystem::ClobberExistingNativeHandler(const std::string& name) {
   NativeHandlerMap::iterator existing_handler = native_handler_map_.find(name);
   if (existing_handler != native_handler_map_.end()) {
     clobbered_native_handlers_.push_back(std::move(existing_handler->second));
     native_handler_map_.erase(existing_handler);
   }
 }
 
@@ skipping 26 matching lines @@
       !value->IsFunction()) {
     Fatal(context_, module_name + "." + method_name + " is not a function");
     return function;
   }
 
   function = v8::Local<v8::Function>::Cast(value);
   return function;
 }
 
 }  // namespace extensions