[Extensions] DCHECK that ExtensionFunctions respond (and only once)

extensions/browser/extension_function.cc

 // Copyright 2013 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/browser/extension_function.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_message_filter.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::WebContents;
 using extensions::ErrorUtils;
 using extensions::ExtensionAPI;
 using extensions::Feature;
@@ skipping 139 matching lines @@
 
 void UserGestureForTests::DecrementCount() {
   base::AutoLock autolock(lock_);
   --count_;
 }
 
 
 }  // namespace
 
 // static
+bool ExtensionFunction::ignore_all_did_respond_for_testing_do_not_use = false;
+
+// static
 void ExtensionFunctionDeleteTraits::Destruct(const ExtensionFunction* x) {
   x->Destruct();
 }
 
 // Helper class to track the lifetime of ExtensionFunction's RenderFrameHost and
 // notify the function when it is deleted, as well as forwarding any messages
 // to the ExtensionFunction.
 class UIThreadExtensionFunction::RenderFrameHostTracker
     : public content::WebContentsObserver {
  public:
@@ skipping 30 matching lines @@
     : request_id_(-1),
       profile_id_(NULL),
       name_(""),
       has_callback_(false),
       include_incognito_(false),
       user_gesture_(false),
       bad_message_(false),
       histogram_value_(extensions::functions::UNKNOWN),
       source_tab_id_(-1),
       source_context_type_(Feature::UNSPECIFIED_CONTEXT),
-      source_process_id_(-1) {
-}
+      source_process_id_(-1),
+      did_respond_(false) {}
 
 ExtensionFunction::~ExtensionFunction() {
 }
 
 UIThreadExtensionFunction* ExtensionFunction::AsUIThreadExtensionFunction() {
   return NULL;
 }
 
 IOThreadExtensionFunction* ExtensionFunction::AsIOThreadExtensionFunction() {
   return NULL;
@@ skipping 129 matching lines @@
 // static
 ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure(
     ExtensionFunction* function) {
   return function->RespondNow(function->BadMessage());
 }
 
 void ExtensionFunction::Respond(ResponseValue result) {
   SendResponse(result->Apply());
 }
 
+bool ExtensionFunction::PreRunValidation(std::string* error) {
+  return true;
+}
+
+ExtensionFunction::ResponseAction ExtensionFunction::RunWithValidation() {
+  std::string error;
+  if (!PreRunValidation(&error)) {
+    DCHECK(!error.empty() || bad_message_);
+    return bad_message_ ? ValidationFailure(this) : RespondNow(Error(error));
+  }
+  return Run();
+}
+
 bool ExtensionFunction::ShouldSkipQuotaLimiting() const {
   return false;
 }
 
 bool ExtensionFunction::HasOptionalArgument(size_t index) {
   base::Value* value;
   return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL);
 }
 
 void ExtensionFunction::SendResponseImpl(bool success) {
@@ skipping 32 matching lines @@
 
 UIThreadExtensionFunction::UIThreadExtensionFunction()
     : context_(nullptr),
       render_frame_host_(nullptr),
       delegate_(nullptr) {
 }
 
 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
   if (dispatcher() && render_frame_host())
     dispatcher()->OnExtensionFunctionCompleted(extension());
+  // The extension function should always respond to avoid leaks in the
+  // renderer, dangling callbacks, etc. The exception is if the system is
+  // shutting down.
+  // TODO(devlin): Duplicate this check in IOThreadExtensionFunction. It's
+  // tricky because checking IsShuttingDown has to be called from the UI thread.
+  DCHECK(extensions::ExtensionsBrowserClient::Get()->IsShuttingDown() ||
+         did_respond_ || ignore_all_did_respond_for_testing_do_not_use)
+      << name_;
 }
 
 UIThreadExtensionFunction*
 UIThreadExtensionFunction::AsUIThreadExtensionFunction() {
   return this;
 }
 
 bool UIThreadExtensionFunction::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
@@ skipping 25 matching lines @@
 
   return web_contents;
 }
 
 content::WebContents* UIThreadExtensionFunction::GetSenderWebContents() {
   return render_frame_host_ ?
       content::WebContents::FromRenderFrameHost(render_frame_host_) : nullptr;
 }
 
 void UIThreadExtensionFunction::SendResponse(bool success) {
+  DCHECK(!did_respond_) << name_;
+  did_respond_ = true;
   if (delegate_)
     delegate_->OnSendResponse(this, success, bad_message_);
   else
     SendResponseImpl(success);
 
   if (!transferred_blob_uuids_.empty()) {
     DCHECK(!delegate_) << "Blob transfer not supported with test delegate.";
     render_frame_host_->Send(
         new ExtensionMsg_TransferBlobs(transferred_blob_uuids_));
   }
@@ skipping 24 matching lines @@
 IOThreadExtensionFunction*
 IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
   return this;
 }
 
 void IOThreadExtensionFunction::Destruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void IOThreadExtensionFunction::SendResponse(bool success) {
+  DCHECK(!did_respond_) << name_;
+  did_respond_ = true;
   SendResponseImpl(success);
 }
 
 AsyncExtensionFunction::AsyncExtensionFunction() {
 }
 
 AsyncExtensionFunction::~AsyncExtensionFunction() {
 }
 
 ExtensionFunction::ScopedUserGestureForTests::ScopedUserGestureForTests() {
@@ skipping 39 matching lines @@
 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
   return RespondNow(RunSync() ? ArgumentList(std::move(results_))
                               : Error(error_));
 }
 
 // static
 bool SyncIOThreadExtensionFunction::ValidationFailure(
     SyncIOThreadExtensionFunction* function) {
   return false;
 }