Move SocketsTcpApiTest.SocketsTcpCreateGood to app_shell_browsertests.

extensions/browser/api_test_utils.cc

 // Copyright 2014 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/api_test_utils.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_dispatcher.h"
+#include "extensions/common/extension_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using extensions::ExtensionFunctionDispatcher;
+
 namespace {
 
+class TestFunctionDispatcherDelegate
+    : public ExtensionFunctionDispatcher::Delegate {
+ public:
+  TestFunctionDispatcherDelegate() {}
+  virtual ~TestFunctionDispatcherDelegate() {}
+
+  // NULL implementation.
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestFunctionDispatcherDelegate);
+};
+
 base::Value* ParseJSON(const std::string& data) {
   return base::JSONReader::Read(data);
 }
 
 base::ListValue* ParseList(const std::string& data) {
   base::Value* result = ParseJSON(data);
   base::ListValue* list = NULL;
   result->GetAsList(&list);
   return list;
 }
@@ skipping 34 matching lines @@
   scoped_ptr<bool> response_;
   bool should_post_quit_;
 };
 
 }  // namespace
 
 namespace extensions {
 
 namespace api_test_utils {
 
+scoped_refptr<Extension> CreateEmptyExtension() {

[Yoyo Zhou, 2014/08/08 01:28:04]

I recently found extensions/common/test_util.h. I think this function would be
better placed there. What do you think?

[Daniel Nishi, 2014/08/08 17:24:08]

I think it looks better, too.

Done.

+  scoped_refptr<Extension> empty_extension(
+      ExtensionBuilder()
+          .SetManifest(
+               DictionaryBuilder().Set("name", "Test").Set("version", "1.0"))
+          .Build());
+  return empty_extension;
+}
+
 base::Value* RunFunctionAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
     scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher) {
   return RunFunctionAndReturnSingleResult(
       function, args, context, dispatcher.Pass(), NONE);
 }
 
 base::Value* RunFunctionAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
     scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
     RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
   // Without a callback the function will not generate a result.
   function->set_has_callback(true);
   RunFunction(function, args, context, dispatcher.Pass(), flags);
   EXPECT_TRUE(function->GetError().empty())
       << "Unexpected error: " << function->GetError();
   const base::Value* single_result = NULL;
   if (function->GetResultList() != NULL &&
       function->GetResultList()->Get(0, &single_result)) {
     return single_result->DeepCopy();
   }
   return NULL;
 }
 
+base::Value* RunDelegatelessFunctionAndReturnSingleResult(

[Yoyo Zhou, 2014/08/08 01:28:04]

I think the default should be with no delegate, since right now we only have
functions that don't need a delegate.

So
RunFunctionAndReturn...
RunFunctionWithDelegateAndReturn...

[Daniel Nishi, 2014/08/08 17:24:08]

Done.

+    UIThreadExtensionFunction* function,
+    const std::string& args,
+    content::BrowserContext* context) {
+  return RunDelegatelessFunctionAndReturnSingleResult(
+      function, args, context, NONE);
+}
+
+base::Value* RunDelegatelessFunctionAndReturnSingleResult(
+    UIThreadExtensionFunction* function,
+    const std::string& args,
+    content::BrowserContext* context,
+    RunFunctionFlags flags) {
+  TestFunctionDispatcherDelegate delegate;
+  scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
+      new ExtensionFunctionDispatcher(context, &delegate));
+
+  return RunFunctionAndReturnSingleResult(
+      function, args, context, dispatcher.Pass(), flags);
+}
+
 bool RunFunction(UIThreadExtensionFunction* function,
                  const std::string& args,
                  content::BrowserContext* context,
                  scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
                  RunFunctionFlags flags) {
   SendResponseDelegate response_delegate;
   function->set_test_delegate(&response_delegate);
   scoped_ptr<base::ListValue> parsed_args(ParseList(args));
   EXPECT_TRUE(parsed_args.get())
       << "Could not parse extension function arguments: " << args;
@@ skipping 12 matching lines @@
     response_delegate.set_should_post_quit(true);
     content::RunMessageLoop();
   }
 
   EXPECT_TRUE(response_delegate.HasResponse());
   return response_delegate.GetResponse();
 }
 
 }  // namespace api_test_utils
 }  // namespace extensions