Fix for management API related to escalated permissions disabled extensions

chrome/browser/extensions/extension_function_test_utils.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/test/base/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestFunctionDispatcherDelegate
     : public ExtensionFunctionDispatcher::Delegate {
  public:
   explicit TestFunctionDispatcherDelegate(Browser* browser) :
       browser_(browser) {}
   virtual ~TestFunctionDispatcherDelegate() {}
@@ skipping 127 matching lines @@
   TestFunctionDispatcherDelegate dispatcher_delegate(browser);
   ExtensionFunctionDispatcher dispatcher(
       browser->profile(), &dispatcher_delegate);
   function->set_dispatcher(dispatcher.AsWeakPtr());
 
   function->set_profile(browser->profile());
   function->set_include_incognito(flags & INCLUDE_INCOGNITO);
   function->Run();
 }
 
+// This helps us be able to wait until an AsyncExtensionFunction calls
+// SendResponse.
+class SendResponseDelegate : public AsyncExtensionFunction::DelegateForTests {
+ public:
+  SendResponseDelegate() : should_post_quit_(false) {}
+
+  virtual ~SendResponseDelegate() {}
+
+  void set_should_post_quit(bool should_quit) {
+    should_post_quit_ = should_quit;
+  }
+
+  bool HasResponse() {
+    return response_.get() != NULL;
+  }
+
+  bool GetResponse() {
+    EXPECT_TRUE(HasResponse());
+    return *response_.get();
+  }
+
+  virtual void OnSendResponse(AsyncExtensionFunction* function, bool success) {
+    ASSERT_FALSE(HasResponse());
+    response_.reset(new bool);
+    *response_ = success;
+    if (should_post_quit_) {
+      MessageLoopForUI::current()->Quit();
+    }
+  }
+
+ private:
+  scoped_ptr<bool> response_;
+  bool should_post_quit_;
+};
+
+bool RunAsyncFunction(AsyncExtensionFunction* function,
+                      const std::string& args,
+                      Browser* browser,
+                      RunFunctionFlags flags) {
+  SendResponseDelegate response_delegate;
+  function->set_test_delegate(&response_delegate);
+  RunFunction(function, args, browser, flags);
+
+  // If the RunImpl of |function| didn't already call SendResponse, run the
+  // message loop until they do.
+  if (!response_delegate.HasResponse()) {
+    response_delegate.set_should_post_quit(true);
+    ui_test_utils::RunMessageLoop();
+  }
+
+  EXPECT_TRUE(response_delegate.HasResponse());
+  return response_delegate.GetResponse();
+}
+
 } // namespace extension_function_test_utils