Rename NavigationController to NavigationControllerImpl and put it into the content namespace. Al...

content/browser/ssl/ssl_policy.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/ssl/ssl_cert_error_handler.h"
 #include "content/browser/ssl/ssl_request_info.h"
-#include "content/browser/tab_contents/navigation_entry.h"
+#include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/ssl_info.h"
 #include "webkit/glue/resource_type.h"
 
+using content::NavigationEntryImpl;
 using content::SSLStatus;
 
 namespace {
 
 static const char kDot = '.';
 
 static bool IsIntranetHost(const std::string& host) {
   const size_t dot = host.find(kDot);
   return dot == std::string::npos || dot == host.length() - 1;
 }
@@ skipping 42 matching lines @@
     case net::ERR_CERT_NOT_IN_DNS:
       OnCertErrorInternal(handler, false);
       break;
     default:
       NOTREACHED();
       handler->CancelRequest();
       break;
   }
 }
 
-void SSLPolicy::DidRunInsecureContent(NavigationEntry* entry,
+void SSLPolicy::DidRunInsecureContent(NavigationEntryImpl* entry,
                                       const std::string& security_origin) {
   if (!entry)
     return;
 
   SiteInstance* site_instance = entry->site_instance();
   if (!site_instance)
       return;
 
   backend_->HostRanInsecureContent(GURL(security_origin).host(),
                                    site_instance->GetProcess()->GetID());
 }
 
 void SSLPolicy::OnRequestStarted(SSLRequestInfo* info) {
   // TODO(abarth): This mechanism is wrong.  What we should be doing is sending
   // this information back through WebKit and out some FrameLoaderClient
   // methods.
 
   if (net::IsCertStatusError(info->ssl_cert_status()))
     backend_->HostRanInsecureContent(info->url().host(), info->child_id());
 }
 
-void SSLPolicy::UpdateEntry(NavigationEntry* entry, TabContents* tab_contents) {
+void SSLPolicy::UpdateEntry(NavigationEntryImpl* entry,
+                            TabContents* tab_contents) {
   DCHECK(entry);
 
   InitializeEntryIfNeeded(entry);
 
   if (!entry->GetURL().SchemeIsSecure())
     return;
 
   // An HTTPS response may not have a certificate for some reason.  When that
   // happens, use the unauthenticated (HTTP) rather than the authentication
   // broken security style so that we can detect this error condition.
@@ skipping 77 matching lines @@
     handler->DenyRequest();
     return;
   }
 
   content::GetContentClient()->browser()->AllowCertificateError(
       handler,
       overridable,
       base::Bind(&SSLPolicy::OnAllowCertificate, base::Unretained(this)));
 }
 
-void SSLPolicy::InitializeEntryIfNeeded(NavigationEntry* entry) {
+void SSLPolicy::InitializeEntryIfNeeded(NavigationEntryImpl* entry) {
   if (entry->GetSSL().security_style != content::SECURITY_STYLE_UNKNOWN)
     return;
 
   entry->GetSSL().security_style = entry->GetURL().SchemeIsSecure() ?
       content::SECURITY_STYLE_AUTHENTICATED :
       content::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);
 }