Fix for management API related to escalated permissions disabled extensions

chrome/browser/extensions/extension_function.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 124 matching lines @@
   // Helper method for ExtensionFunctionDeleteTraits. Deletes this object.
   virtual void Destruct() const = 0;
 
   // Derived classes should implement this method to do their work and return
   // success/failure.
   virtual bool RunImpl() = 0;
 
   // Sends the result back to the extension.
   virtual void SendResponse(bool success) = 0;
 
-  // Common implementation for SenderResponse.
+  // Common implementation for SendResponse.
   void SendResponseImpl(base::ProcessHandle process,
                         IPC::Message::Sender* ipc_sender,
                         int routing_id,
                         bool success);
 
   // Called when we receive an extension api request that is invalid in a way
   // that JSON validation in the renderer should have caught. This should never
   // happen and could be an attacker trying to exploit the browser, so we crash
   // the renderer instead.
   void HandleBadMessage(base::ProcessHandle process);
@@ skipping 177 matching lines @@
   base::WeakPtr<ChromeRenderMessageFilter> ipc_sender_;
   int routing_id_;
 
   scoped_refptr<const ExtensionInfoMap> extension_info_map_;
 };
 
 // Base class for an extension function that runs asynchronously *relative to
 // the browser's UI thread*.
 class AsyncExtensionFunction : public UIThreadExtensionFunction {
  public:
+  // A delegate for use in testing, to intercept the call to SendResponse.
+  class DelegateForTests {
+   public:
+    virtual void OnSendResponse(AsyncExtensionFunction* function,
+                                bool success) = 0;
+  };
+
   AsyncExtensionFunction();
+  virtual void SendResponse(bool success) OVERRIDE;
+
+  void set_test_delegate(DelegateForTests* delegate) {
+    delegate_ = delegate;
+  }
 
  protected:
   virtual ~AsyncExtensionFunction();
+
+  DelegateForTests* delegate_;
 };
 
 // A SyncExtensionFunction is an ExtensionFunction that runs synchronously
 // *relative to the browser's UI thread*. Note that this has nothing to do with
 // running synchronously relative to the extension process. From the extension
 // process's point of view, the function is still asynchronous.
 //
 // This kind of function is convenient for implementing simple APIs that just
 // need to interact with things on the browser UI thread.
 class SyncExtensionFunction : public UIThreadExtensionFunction {
@@ skipping 10 matching lines @@
  public:
   SyncIOThreadExtensionFunction();
 
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~SyncIOThreadExtensionFunction();
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_