Define the public interface for content browser SiteInstance. This interface is implemented by th...

content/browser/tab_contents/navigation_controller_impl.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/tab_contents/navigation_controller_impl.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_url_handler.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/renderer_host/render_view_host.h"  // Temporary
-#include "content/browser/site_instance.h"
+#include "content/browser/site_instance_impl.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_constants.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::BrowserContext;
 using content::GlobalRequestID;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
+using content::SiteInstance;
 using content::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
 const int kInvalidateAll = 0xFFFFFFFF;
 
 // Invoked when entries have been pruned, or removed. For example, if the
 // current entries are [google, digg, yahoo], with the current entry google,
 // and the user types in cnet, then digg and yahoo are pruned.
@@ skipping 234 matching lines @@
     ReloadInternal(false, pending_reload_);
     pending_reload_ = NO_RELOAD;
   }
 }
 
 bool NavigationControllerImpl::IsInitialNavigation() {
   return last_document_loaded_.is_null();
 }
 
 NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
-    SiteInstance* instance, int32 page_id) const {
+  SiteInstance* instance, int32 page_id) const {
   int index = GetEntryIndexWithPageID(instance, page_id);
   return (index != -1) ? entries_[index].get() : NULL;
 }
 
 void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
   // Don't navigate to URLs disabled by policy. This prevents showing the URL
   // on the Omnibar when it is also going to be blocked by
   // ChildProcessSecurityPolicy::CanRequestURL.
   ChildProcessSecurityPolicy *policy =
       ChildProcessSecurityPolicy::GetInstance();
@@ skipping 412 matching lines @@
     temp.append(base::IntToString(params.frame_id));
     temp.append("#ids");
     for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
       // Append entry metadata (e.g., 3_7x):
       //  3: page_id
       //  7: SiteInstance ID, or N for null
       //  x: appended if not from the current SiteInstance
       temp.append(base::IntToString(entries_[i]->GetPageID()));
       temp.append("_");
       if (entries_[i]->site_instance())
-        temp.append(base::IntToString(entries_[i]->site_instance()->id()));
+        temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
       else
         temp.append("N");
       if (entries_[i]->site_instance() != tab_contents_->GetSiteInstance())
         temp.append("x");
       temp.append(",");
     }
     GURL url(temp);
     tab_contents_->GetRenderViewHost()->Send(new ViewMsg_TempCrashWithData(url));
     return content::NAVIGATION_TYPE_NAV_IGNORE;
   }
@@ skipping 68 matching lines @@
     // the URL.
     update_virtual_url = true;
   }
 
   new_entry->SetURL(params.url);
   if (update_virtual_url)
     UpdateVirtualURLToURL(new_entry, params.url);
   new_entry->SetReferrer(params.referrer);
   new_entry->SetPageID(params.page_id);
   new_entry->SetTransitionType(params.transition);
-  new_entry->set_site_instance(tab_contents_->GetSiteInstance());
+  new_entry->set_site_instance(
+      static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
   new_entry->SetHasPostData(params.is_post);
 
   InsertOrReplaceEntry(new_entry, *did_replace_entry);
 }
 
 void NavigationControllerImpl::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We should only get here for main frame navigations.
   DCHECK(content::PageTransitionIsMainFrame(params.transition));
 
   // This is a back/forward navigation. The existing page for the ID is
   // guaranteed to exist by ClassifyNavigation, and we just need to update it
   // with new information from the renderer.
   int entry_index = GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
   NavigationEntryImpl* entry = entries_[entry_index].get();
 
   // The URL may have changed due to redirects. The site instance will normally
   // be the same except during session restore, when no site instance will be
   // assigned.
   entry->SetURL(params.url);
   if (entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(entry, params.url);
   DCHECK(entry->site_instance() == NULL ||
          entry->site_instance() == tab_contents_->GetSiteInstance());
-  entry->set_site_instance(tab_contents_->GetSiteInstance());
+  entry->set_site_instance(
+      static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
 
   entry->SetHasPostData(params.is_post);
 
   // The entry we found in the list might be pending if the user hit
   // back/forward/reload. This load should commit it (since it's already in the
   // list, we can just discard the pending pointer).  We should also discard the
   // pending entry if it corresponds to a different navigation, since that one
   // is now likely canceled.  If it is not canceled, we will treat it as a new
   // navigation when it arrives, which is also ok.
   //
@@ skipping 386 matching lines @@
 
   if (!tab_contents_->NavigateToPendingEntry(reload_type))
     DiscardNonCommittedEntries();
 
   // If the entry is being restored and doesn't have a SiteInstance yet, fill
   // it in now that we know. This allows us to find the entry when it commits.
   // This works for browser-initiated navigations. We handle renderer-initiated
   // navigations to restored entries in TabContents::OnGoToEntryAtOffset.
   if (pending_entry_ && !pending_entry_->site_instance() &&
       pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
-    pending_entry_->set_site_instance(tab_contents_->GetPendingSiteInstance());
+    pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
+        tab_contents_->GetPendingSiteInstance()));
     pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
   }
 }
 
 void NavigationControllerImpl::NotifyNavigationEntryCommitted(
     content::LoadCommittedDetails* details) {
   details->entry = GetActiveEntry();
   content::NotificationDetails notification_details =
       content::Details<content::LoadCommittedDetails>(details);
 
@@ skipping 99 matching lines @@
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->GetPageType() !=
         content::PAGE_TYPE_INTERSTITIAL) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntryImpl>(
                           new NavigationEntryImpl(*source.entries_[i])));
     }
   }
 }