Improve error messages for bad SocketParams.

net/socket/client_socket_pool_base_unittest.cc

 // Copyright (c) 2010 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 "net/socket/client_socket_pool_base.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
@@ skipping 12 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const int kDefaultMaxSockets = 4;
 const int kDefaultMaxSocketsPerGroup = 2;
 const net::RequestPriority kDefaultPriority = MEDIUM;
 
-typedef const void* TestSocketParams;
+struct TestSocketParams {};
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
 class MockClientSocket : public ClientSocket {
  public:
   MockClientSocket() : connected_(false) {}
 
   // Socket methods:
   virtual int Read(
       IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) {
     return ERR_UNEXPECTED;
@@ skipping 248 matching lines @@
               unused_idle_socket_timeout, used_idle_socket_timeout,
               connect_job_factory, NULL) {}
 
   virtual int RequestSocket(
       const std::string& group_name,
       const void* params,
       net::RequestPriority priority,
       ClientSocketHandle* handle,
       CompletionCallback* callback,
       const BoundNetLog& net_log) {
+    const TestSocketParams* casted_socket_params =
+        static_cast<const TestSocketParams*>(params);
     return base_.RequestSocket(
-        group_name, params, priority, handle, callback, net_log);
+        group_name, *casted_socket_params, priority, handle, callback, net_log);
   }
 
   virtual void CancelRequest(
       const std::string& group_name,
       const ClientSocketHandle* handle) {
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
@@ skipping 117 matching lines @@
     pool_ = new TestClientSocketPool(max_sockets,
                                      max_sockets_per_group,
                                      histograms_,
                                      unused_idle_socket_timeout,
                                      used_idle_socket_timeout,
                                      connect_job_factory_);
   }
 
   int StartRequest(const std::string& group_name,
                    net::RequestPriority priority) {
+    TestSocketParams params;
     return StartRequestUsingPool<TestClientSocketPool, TestSocketParams>(
-        pool_, group_name, priority, NULL);
+        pool_, group_name, priority, params);
   }
 
   virtual void TearDown() {
     // We post all of our delayed tasks with a 2ms delay. I.e. they don't
     // actually become pending until 2ms after they have been created. In order
     // to flush all tasks, we need to wait so that we know there are no
     // soon-to-be-pending tasks waiting.
     PlatformThread::Sleep(10);
     MessageLoop::current()->RunAllPending();
 
@@ skipping 14 matching lines @@
 };
 
 // Helper function which explicitly specifies the template parameters, since
 // the compiler will infer (in this case, incorrectly) that NULL is of type int.
 int InitHandle(ClientSocketHandle* handle,
                const std::string& group_name,
                net::RequestPriority priority,
                CompletionCallback* callback,
                const scoped_refptr<TestClientSocketPool>& pool,
                const BoundNetLog& net_log) {
+  TestSocketParams params;
   return handle->Init<TestSocketParams, TestClientSocketPool>(
-      group_name, NULL, priority, callback, pool, net_log);
+      group_name, params, priority, callback, pool, net_log);
 }
 
 // Even though a timeout is specified, it doesn't time out on a synchronous
 // completion.
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
+  TestSocketParams params;
   TestClientSocketPoolBase::Request request(
-      &ignored, NULL, kDefaultPriority, NULL, BoundNetLog());
+      &ignored, NULL, kDefaultPriority, params, BoundNetLog());
   scoped_ptr<TestConnectJob> job(
       new TestConnectJob(TestConnectJob::kMockJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
                          NULL));
   EXPECT_EQ(OK, job->Connect());
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
+  TestSocketParams params;
   TestClientSocketPoolBase::Request request(
-      &ignored, NULL, kDefaultPriority, NULL, BoundNetLog());
+      &ignored, NULL, kDefaultPriority, params, BoundNetLog());
   // Deleted by TestConnectJobDelegate.
   TestConnectJob* job =
       new TestConnectJob(TestConnectJob::kMockPendingJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
                          &log);
   ASSERT_EQ(ERR_IO_PENDING, job->Connect());
@@ skipping 1254 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING,
             InitHandle(&handle, "a", kDefaultPriority,
                        &callback, pool_, BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 }
 
 }  // namespace
 
 }  // namespace net