chrome.clear: Increasing granularity of public API

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"
@@ skipping 121 matching lines @@
 }
 base::Value* RunFunctionAndReturnResult(UIThreadExtensionFunction* function,
                                         const std::string& args,
                                         Browser* browser,
                                         RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
   RunFunction(function, args, browser, flags);
   EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
       << function->GetError();
   EXPECT_TRUE(function->GetResultValue()) << "No result value found";
   return function->GetResultValue()->DeepCopy();

[Aaron Boodman, 2011/12/14 22:23:46]

Was the only reason RunFunctionWithoutResult needed because this line crashes if
the function doesn't return a value? If so you could modify it to check
GetResultValue() is not NULL and return NULL if so.

[Mike West, 2011/12/14 22:41:59]

Yes, that's what I originally did. Having a separate function has, however, the
nice side effect of letting us assert that there's no result (line #158).

I don't have a strong opinion on it, though, If you'd rather stick with the one
function, I'll modify it as you've suggested.

[Aaron Boodman, 2011/12/14 22:44:35]

You can just do that assertion at the call site.

In code like this I've worked with in the past, there is a big problem of
combinatorial explosion. I'm trying to keep that to a low roar this time.

So yeah, I'd prefer not having these functions if it works for you.

[Mike West, 2011/12/14 22:59:03]

Done.

 }
 
+bool RunFunctionWithoutResult(UIThreadExtensionFunction* function,
+                              const std::string& args,
+                              Browser* browser) {
+  return RunFunctionWithoutResult(function, args, browser, NONE);
+}
+bool RunFunctionWithoutResult(UIThreadExtensionFunction* function,
+                              const std::string& args,
+                              Browser* browser,
+                              RunFunctionFlags flags) {
+  scoped_refptr<ExtensionFunction> function_owner(function);
+  bool success = RunFunction(function, args, browser, flags);
+  EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
+      << function->GetError();
+  EXPECT_FALSE(function->GetResultValue()) << "Unexpected result value: "
+      << function->GetResult();
+  return success;
+}
+
 // This helps us be able to wait until an AsyncExtensionFunction calls
 // SendResponse.
 class SendResponseDelegate
     : public UIThreadExtensionFunction::DelegateForTests {
  public:
   SendResponseDelegate() : should_post_quit_(false) {}
 
   virtual ~SendResponseDelegate() {}
 
   void set_should_post_quit(bool should_quit) {
@@ skipping 49 matching lines @@
   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