Pull SecurityStateModel out into a component

components/security_state/security_state_model_unittest.cc

 // Copyright 2015 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/ssl/security_state_model.h"
+#include "components/security_state/security_state_model.h"
 
 #include <stdint.h>
 
-#include "chrome/browser/ssl/security_state_model_client.h"
-#include "chrome/test/base/chrome_render_view_host_test_harness.h"
-#include "chrome/test/base/testing_profile.h"
-#include "content/public/browser/cert_store.h"
-#include "content/public/common/origin_util.h"
-#include "content/public/test/mock_render_process_host.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include "components/security_state/security_state_model_client.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/x509_certificate.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_certificate_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace security_state {
+
 namespace {
 
 const char kUrl[] = "https://foo.test";
 
 class TestSecurityStateModelClient : public SecurityStateModelClient {
  public:
   TestSecurityStateModelClient()
       : initial_security_level_(SecurityStateModel::SECURE),
         connection_status_(net::SSL_CONNECTION_VERSION_TLS1_2
                            << net::SSL_CONNECTION_VERSION_SHIFT),
@@ skipping 39 matching lines @@
     state->ran_mixed_content = ran_mixed_content_;
   }
 
   bool RetrieveCert(scoped_refptr<net::X509Certificate>* cert) override {
     *cert = cert_;
     return true;
   }
 
   bool UsedPolicyInstalledCertificate() override { return false; }
 
-  bool IsOriginSecure(const GURL& url) override {
-    return content::IsOriginSecure(url);
-  }
+  bool IsOriginSecure(const GURL& url) override { return true; }

[eroman, 2016/01/11 18:12:12]

Without knowing more about this test, why is this change correct? Is the
assumption that all the tests are calling this with secure origins, or that this
doesn't matter for the test?

[estark, 2016/01/11 18:15:52]

The former (all tests are using secure origins). I'll add a comment saying so.

 
  private:
   SecurityStateModel::SecurityLevel initial_security_level_;
   scoped_refptr<net::X509Certificate> cert_;
   int connection_status_;
   net::CertStatus cert_status_;
   bool displayed_mixed_content_;
   bool ran_mixed_content_;
 };
 
-class SecurityStateModelTest : public ChromeRenderViewHostTestHarness {};
-
 // Tests that SHA1-signed certificates expiring in 2016 downgrade the
 // security state of the page.
-TEST_F(SecurityStateModelTest, SHA1Warning) {
+TEST(SecurityStateModelTest, SHA1Warning) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   const SecurityStateModel::SecurityInfo& security_info =
       model.GetSecurityInfo();
   EXPECT_EQ(SecurityStateModel::DEPRECATED_SHA1_MINOR,
             security_info.sha1_deprecation_status);
   EXPECT_EQ(SecurityStateModel::NONE, security_info.security_level);
 }
 
 // Tests that SHA1 warnings don't interfere with the handling of mixed
 // content.
-TEST_F(SecurityStateModelTest, SHA1WarningMixedContent) {
+TEST(SecurityStateModelTest, SHA1WarningMixedContent) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   client.SetDisplayedMixedContent(true);
   const SecurityStateModel::SecurityInfo& security_info1 =
       model.GetSecurityInfo();
   EXPECT_EQ(SecurityStateModel::DEPRECATED_SHA1_MINOR,
             security_info1.sha1_deprecation_status);
   EXPECT_EQ(SecurityStateModel::DISPLAYED_MIXED_CONTENT,
             security_info1.mixed_content_status);
   EXPECT_EQ(SecurityStateModel::NONE, security_info1.security_level);
 
   client.set_initial_security_level(SecurityStateModel::SECURITY_ERROR);
   client.SetDisplayedMixedContent(false);
   client.SetRanMixedContent(true);
   const SecurityStateModel::SecurityInfo& security_info2 =
       model.GetSecurityInfo();
   EXPECT_EQ(SecurityStateModel::DEPRECATED_SHA1_MINOR,
             security_info2.sha1_deprecation_status);
   EXPECT_EQ(SecurityStateModel::RAN_MIXED_CONTENT,
             security_info2.mixed_content_status);
   EXPECT_EQ(SecurityStateModel::SECURITY_ERROR, security_info2.security_level);
 }
 
 // Tests that SHA1 warnings don't interfere with the handling of major
 // cert errors.
-TEST_F(SecurityStateModelTest, SHA1WarningBrokenHTTPS) {
+TEST(SecurityStateModelTest, SHA1WarningBrokenHTTPS) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   client.set_initial_security_level(SecurityStateModel::SECURITY_ERROR);
   client.AddCertStatus(net::CERT_STATUS_DATE_INVALID);
   const SecurityStateModel::SecurityInfo& security_info =
       model.GetSecurityInfo();
   EXPECT_EQ(SecurityStateModel::DEPRECATED_SHA1_MINOR,
             security_info.sha1_deprecation_status);
   EXPECT_EQ(SecurityStateModel::SECURITY_ERROR, security_info.security_level);
 }
 
 // Tests that |security_info.is_secure_protocol_and_ciphersuite| is
 // computed correctly.
-TEST_F(SecurityStateModelTest, SecureProtocolAndCiphersuite) {
+TEST(SecurityStateModelTest, SecureProtocolAndCiphersuite) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 from
   // http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-4
   const uint16_t ciphersuite = 0xc02f;
   client.set_connection_status(net::SSL_CONNECTION_VERSION_TLS1_2
                                << net::SSL_CONNECTION_VERSION_SHIFT);
   client.SetCipherSuite(ciphersuite);
   const SecurityStateModel::SecurityInfo& security_info =
       model.GetSecurityInfo();
   EXPECT_TRUE(security_info.is_secure_protocol_and_ciphersuite);
 }
 
-TEST_F(SecurityStateModelTest, NonsecureProtocol) {
+TEST(SecurityStateModelTest, NonsecureProtocol) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 from
   // http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-4
   const uint16_t ciphersuite = 0xc02f;
   client.set_connection_status(net::SSL_CONNECTION_VERSION_TLS1_1
                                << net::SSL_CONNECTION_VERSION_SHIFT);
   client.SetCipherSuite(ciphersuite);
   const SecurityStateModel::SecurityInfo& security_info =
       model.GetSecurityInfo();
   EXPECT_FALSE(security_info.is_secure_protocol_and_ciphersuite);
 }
 
-TEST_F(SecurityStateModelTest, NonsecureCiphersuite) {
+TEST(SecurityStateModelTest, NonsecureCiphersuite) {
   TestSecurityStateModelClient client;
   SecurityStateModel model;
   model.SetClient(&client);
   // TLS_RSA_WITH_AES_128_CCM_8 from
   // http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-4
   const uint16_t ciphersuite = 0xc0a0;
   client.set_connection_status(net::SSL_CONNECTION_VERSION_TLS1_2
                                << net::SSL_CONNECTION_VERSION_SHIFT);
   client.SetCipherSuite(ciphersuite);
   const SecurityStateModel::SecurityInfo& security_info =
       model.GetSecurityInfo();
   EXPECT_FALSE(security_info.is_secure_protocol_and_ciphersuite);
 }
 
 }  // namespace
+
+}  // namespace security_state