[Extensions Bindings] Add chrome.runtime.lastError support

extensions/renderer/api_last_error.cc

Index: extensions/renderer/api_last_error.cc
diff --git a/extensions/renderer/api_last_error.cc b/extensions/renderer/api_last_error.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bb522184bf1468183e0f72e2c46d3d19f2691ac0
--- /dev/null
+++ b/extensions/renderer/api_last_error.cc
@@ -0,0 +1,123 @@
+// 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 "gin/converter.h"
+#include "gin/handle.h"
+#include "gin/object_template_builder.h"
+#include "gin/wrappable.h"
+
+namespace extensions {
+
+namespace {
+
+const char kLastErrorProperty[] = "lastError";
+
+class LastErrorObject final : public gin::Wrappable<LastErrorObject> {
+ public:
+  explicit LastErrorObject(const std::string& error) : error_(error) {}
+
+  static gin::WrapperInfo kWrapperInfo;
+
+  // gin::Wrappable:
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override {
+    DCHECK(isolate);
+    return Wrappable<LastErrorObject>::GetObjectTemplateBuilder(isolate)
+        .SetProperty("message", &LastErrorObject::GetLastError);
+  }
+
+  void Reset(const std::string& error) {
+    error_ = error;
+    accessed_ = false;
+  }
+
+  const std::string& error() const { return error_; }
+  bool accessed() const { return accessed_; }
+
+ private:
+  std::string GetLastError() {
+    accessed_ = true;
+    return error_;
+  }
+
+  std::string error_;
+  bool accessed_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(LastErrorObject);
+};
+
+gin::WrapperInfo LastErrorObject::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+}  // namespace
+
+APILastError::APILastError(const GetParent& get_parent)
+    : get_parent_(get_parent) {}
+APILastError::APILastError(APILastError&& other) = default;
+APILastError::~APILastError() = default;
+
+void APILastError::SetError(v8::Local<v8::Context> context,
+                            const std::string& error) {
+  v8::Isolate* isolate = context->GetIsolate();
+  DCHECK(isolate);
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> parent = get_parent_.Run(context);
+  if (parent.IsEmpty())
+    return;
+  v8::Local<v8::String> key = gin::StringToSymbol(isolate, kLastErrorProperty);
+  v8::MaybeLocal<v8::Value> maybe_error = parent->Get(context, key);
+  v8::Local<v8::Value> local_error;
+  if (!maybe_error.ToLocal(&local_error))
+    return;
+
+  if (!local_error->IsUndefined()) {
+    // There may be an existing last error to overwrite.
+    LastErrorObject* last_error = nullptr;
+    if (!gin::Converter<LastErrorObject*>::FromV8(context->GetIsolate(),
+                                                  local_error, &last_error)) {
+      // If it's not a real lastError (e.g. if a script manually set it), don't
+      // do anything.
+      return;
+    }
+    last_error->Reset(error);
+  } else {
+    DCHECK(context->GetIsolate());
+    v8::Local<v8::Value> last_error =
+        gin::CreateHandle(context->GetIsolate(), new LastErrorObject(error))
+            .ToV8();
+    DCHECK(!last_error.IsEmpty());
+    // This Set() can fail, but there's nothing else to do if it does.
+    ignore_result(parent->Set(
+        context, gin::StringToSymbol(isolate, kLastErrorProperty), last_error));
+  }
+}
+
+void APILastError::ClearError(v8::Local<v8::Context> context,
+                              bool report_if_unchecked) {
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> parent = get_parent_.Run(context);
+  if (parent.IsEmpty())
+    return;
+  v8::Local<v8::String> key = gin::StringToSymbol(isolate, kLastErrorProperty);
+  v8::MaybeLocal<v8::Value> maybe_error = parent->Get(context, key);
+  v8::Local<v8::Value> local_error;
+  if (!maybe_error.ToLocal(&local_error))
+    return;
+  LastErrorObject* last_error = nullptr;
+  if (!gin::Converter<LastErrorObject*>::FromV8(context->GetIsolate(),
+                                                local_error, &last_error)) {
+    return;
+  }
+
+  if (report_if_unchecked && !last_error->accessed()) {
+    isolate->ThrowException(
+        v8::Exception::Error(gin::StringToV8(isolate, last_error->error())));
+  }
+
+  parent->Delete(context, key);

[jbroman, 2017/01/30 23:08:34]

Warning: v8::Object::Delete can throw an exception. I'm not sure whether one can
actually happen here (a lot them can only happen in strict mode), but we should
be looking at the return value of Delete.

[Devlin, 2017/01/31 17:15:00]

What should we do with the result?  Similar to line 92, it may throw, but if it
does, is there any different behavior we want?  Or can we assume that this
should never throw, and CHECK the result?

[jbroman, 2017/02/06 18:31:26]

I'm not sure. We could:
- let it be/rethrow (but we should probably signal to the caller that it should
abort, rather than continuing as though nothing has happened)
- CHECK (though since we believe this not to be impossible, that's arguably
outside what CHECK is for)
- catch and suppress it

At the moment, though the exception seems to just sit on the isolate, and I'm
not confident it will necessarily be thrown to script at a place where we expect
it.

[Devlin, 2017/02/06 20:28:22]

As discussed offline, we'll catch the error (verbosely), so that callers don't
have to worry about it, but we'll still surface data to the extension if
anything funky happens.

+}
+
+}  // namespace extensions