Fixes for -Wunused-function on Linux, Android and ChromeOS

net/ssl/server_bound_cert_service_unittest.cc

 // Copyright (c) 2012 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/ssl/server_bound_cert_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/task_runner.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/x509_certificate.h"
 #include "net/ssl/default_server_bound_cert_store.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
+#if !defined(USE_OPENSSL)
 void FailTest(int /* result */) {
   FAIL();
 }
 
 // Simple task runner that refuses to actually post any tasks. This simulates
 // a TaskRunner that has been shutdown, by returning false for any attempt to
 // add new tasks.
 class FailingTaskRunner : public base::TaskRunner {
  public:
   FailingTaskRunner() {}
 
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
                                base::TimeDelta delay) OVERRIDE {
     return false;
   }
 
   virtual bool RunsTasksOnCurrentThread() const OVERRIDE { return true; }
 
  protected:
   virtual ~FailingTaskRunner() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FailingTaskRunner);
 };
 
-class ServerBoundCertServiceTest : public testing::Test {
- public:
-  ServerBoundCertServiceTest()
-      : service_(new ServerBoundCertService(
-            new DefaultServerBoundCertStore(NULL),
-            base::MessageLoopProxy::current())) {
-  }
-
- protected:
-  scoped_ptr<ServerBoundCertService> service_;
-};
-
 class MockServerBoundCertStoreWithAsyncGet
     : public DefaultServerBoundCertStore {
  public:
   MockServerBoundCertStoreWithAsyncGet()
       : DefaultServerBoundCertStore(NULL), cert_count_(0) {}
 
   virtual int GetServerBoundCert(const std::string& server_identifier,
                                  base::Time* expiration_time,
                                  std::string* private_key_result,
                                  std::string* cert_result,
@@ skipping 46 matching lines @@
     cert_count_ = 1;
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback_,
                                                     err,
                                                     server_identifier_,
                                                     expiration_time,
                                                     private_key,
                                                     cert));
 }
 
+#endif  // !defined(USE_OPENSSL)
+
+class ServerBoundCertServiceTest : public testing::Test {
+ public:
+  ServerBoundCertServiceTest()
+      : service_(new ServerBoundCertService(
+            new DefaultServerBoundCertStore(NULL),
+            base::MessageLoopProxy::current())) {
+  }
+
+ protected:
+  scoped_ptr<ServerBoundCertService> service_;
+};
+
 TEST_F(ServerBoundCertServiceTest, GetDomainForHost) {
   EXPECT_EQ("google.com",
             ServerBoundCertService::GetDomainForHost("google.com"));
   EXPECT_EQ("google.com",
             ServerBoundCertService::GetDomainForHost("www.google.com"));
   EXPECT_EQ("foo.appspot.com",
             ServerBoundCertService::GetDomainForHost("foo.appspot.com"));
   EXPECT_EQ("bar.appspot.com",
             ServerBoundCertService::GetDomainForHost("foo.bar.appspot.com"));
   EXPECT_EQ("appspot.com",
@@ skipping 629 matching lines @@
   EXPECT_EQ(private_key1, private_key2);
   EXPECT_FALSE(request_handle1.is_active());
   EXPECT_FALSE(request_handle2.is_active());
 }
 
 #endif  // !defined(USE_OPENSSL)
 
 }  // namespace
 
 }  // namespace net