Interstitial options are not OR'd properly.

content/browser/ssl/ssl_policy.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 "content/browser/ssl/ssl_policy.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
@@ skipping 39 matching lines @@
   // user every time they come back to the page.
   int options_mask = 0;
   switch (handler->cert_error()) {
     case net::ERR_CERT_COMMON_NAME_INVALID:
     case net::ERR_CERT_DATE_INVALID:
     case net::ERR_CERT_AUTHORITY_INVALID:
     case net::ERR_CERT_WEAK_SIGNATURE_ALGORITHM:
     case net::ERR_CERT_WEAK_KEY:
     case net::ERR_CERT_NAME_CONSTRAINT_VIOLATION:
       if (!handler->fatal())
-        options_mask |= OVERRIDABLE;
+        options_mask |= ContentBrowserClient::OVERRIDABLE;
       else
-        options_mask |= STRICT_ENFORCEMENT;
+        options_mask |= ContentBrowserClient::STRICT_ENFORCEMENT;
       if (expired_previous_decision)
-        options_mask |= EXPIRED_PREVIOUS_DECISION;
+        options_mask |= ContentBrowserClient::EXPIRED_PREVIOUS_DECISION;
       OnCertErrorInternal(handler, options_mask);
       break;
     case net::ERR_CERT_NO_REVOCATION_MECHANISM:
       // Ignore this error.
       handler->ContinueRequest();
       break;
     case net::ERR_CERT_UNABLE_TO_CHECK_REVOCATION:
       // We ignore this error but will show a warning status in the location
       // bar.
       handler->ContinueRequest();
       break;
     case net::ERR_CERT_CONTAINS_ERRORS:
     case net::ERR_CERT_REVOKED:
     case net::ERR_CERT_INVALID:
     case net::ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY:
     case net::ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN:
       if (handler->fatal())
-        options_mask |= STRICT_ENFORCEMENT;
+        options_mask |= ContentBrowserClient::STRICT_ENFORCEMENT;
       if (expired_previous_decision)
-        options_mask |= EXPIRED_PREVIOUS_DECISION;
+        options_mask |= ContentBrowserClient::EXPIRED_PREVIOUS_DECISION;
       OnCertErrorInternal(handler, options_mask);
       break;
     default:
       NOTREACHED();
       handler->CancelRequest();
       break;
   }
 }
 
 void SSLPolicy::DidRunInsecureContent(NavigationEntryImpl* entry,
@@ skipping 87 matching lines @@
     // Default behavior for rejecting a certificate.
     handler->CancelRequest();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Certificate Error Routines
 
 void SSLPolicy::OnCertErrorInternal(SSLCertErrorHandler* handler,
                                     int options_mask) {
-  bool overridable = (options_mask & OVERRIDABLE) != 0;
-  bool strict_enforcement = (options_mask & STRICT_ENFORCEMENT) != 0;
-  bool expired_previous_decision =
-      (options_mask & EXPIRED_PREVIOUS_DECISION) != 0;
   CertificateRequestResultType result =
       CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE;
   GetContentClient()->browser()->AllowCertificateError(
       handler->render_process_id(),
       handler->render_frame_id(),
       handler->cert_error(),
       handler->ssl_info(),
       handler->request_url(),
       handler->resource_type(),
-      overridable,
-      strict_enforcement,
-      expired_previous_decision,
+      options_mask,
       base::Bind(&SSLPolicy::OnAllowCertificate,
                  base::Unretained(this),
                  make_scoped_refptr(handler)),
       &result);
   switch (result) {
     case CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE:
       break;
     case CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL:
       handler->CancelRequest();
       break;
@@ skipping 13 matching lines @@
       SECURITY_STYLE_AUTHENTICATED : SECURITY_STYLE_UNAUTHENTICATED;
 }
 
 void SSLPolicy::OriginRanInsecureContent(const std::string& origin, int pid) {
   GURL parsed_origin(origin);
   if (parsed_origin.SchemeIsSecure())
     backend_->HostRanInsecureContent(parsed_origin.host(), pid);
 }
 
 }  // namespace content