Revert "Don't update TabSpecificContentSettings on same-page navigation"

chrome/browser/content_settings/tab_specific_content_settings.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 "chrome/browser/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 19 matching lines @@
 #include "components/content_settings/core/browser/content_settings_details.h"
 #include "components/content_settings/core/browser/content_settings_info.h"
 #include "components/content_settings/core/browser/content_settings_registry.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_constants.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "storage/common/fileapi/file_system_types.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(TabSpecificContentSettings);
+
 namespace {
 
-static TabSpecificContentSettings* GetForWCGetter(
-    const base::Callback<content::WebContents*(void)>& wc_getter) {
-  WebContents* web_contents = wc_getter.Run();
-  if (!web_contents)
-    return nullptr;
-
-  return TabSpecificContentSettings::FromWebContents(web_contents);
+ContentSettingsUsagesState::CommittedDetails GetCommittedDetails(
+    const content::LoadCommittedDetails& details) {
+  ContentSettingsUsagesState::CommittedDetails committed_details;
+  committed_details.current_url_valid = !!details.entry;
+  if (details.entry)
+    committed_details.current_url = details.entry->GetURL();
+  committed_details.previous_url = details.previous_url;
+  return committed_details;
 }
 
 }  // namespace
 
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(TabSpecificContentSettings);
-
 TabSpecificContentSettings::SiteDataObserver::SiteDataObserver(
     TabSpecificContentSettings* tab_specific_content_settings)
     : tab_specific_content_settings_(tab_specific_content_settings) {
   tab_specific_content_settings_->AddSiteDataObserver(this);
 }
 
 TabSpecificContentSettings::SiteDataObserver::~SiteDataObserver() {
   if (tab_specific_content_settings_)
     tab_specific_content_settings_->RemoveSiteDataObserver(this);
 }
@@ skipping 44 matching lines @@
   content::RenderFrameHost* frame = content::RenderFrameHost::FromID(
       render_process_id, render_frame_id);
   WebContents* web_contents = WebContents::FromRenderFrameHost(frame);
   if (!web_contents)
     return nullptr;
 
   return TabSpecificContentSettings::FromWebContents(web_contents);
 }
 
 // static
-void TabSpecificContentSettings::CookiesRead(
-    const base::Callback<content::WebContents*(void)>& wc_getter,
-    const GURL& url,
-    const GURL& frame_url,
-    const net::CookieList& cookie_list,
-    bool blocked_by_policy) {
+void TabSpecificContentSettings::CookiesRead(int render_process_id,
+                                             int render_frame_id,
+                                             const GURL& url,
+                                             const GURL& frame_url,
+                                             const net::CookieList& cookie_list,
+                                             bool blocked_by_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  TabSpecificContentSettings* settings = GetForWCGetter(wc_getter);
+  TabSpecificContentSettings* settings =
+      GetForFrame(render_process_id, render_frame_id);
   if (settings) {
     settings->OnCookiesRead(url, frame_url, cookie_list,
                             blocked_by_policy);
   }
 }
 
 // static
 void TabSpecificContentSettings::CookieChanged(
-    const base::Callback<WebContents*(void)>& wc_getter,
+    int render_process_id,
+    int render_frame_id,
     const GURL& url,
     const GURL& frame_url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
     bool blocked_by_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  TabSpecificContentSettings* settings = GetForWCGetter(wc_getter);
+  TabSpecificContentSettings* settings =
+      GetForFrame(render_process_id, render_frame_id);
   if (settings)
     settings->OnCookieChanged(url, frame_url, cookie_line, options,
                               blocked_by_policy);
 }
 
 // static
 void TabSpecificContentSettings::WebDatabaseAccessed(
     int render_process_id,
     int render_frame_id,
     const GURL& url,
@@ skipping 621 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(TabSpecificContentSettings, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ContentBlocked,
                         OnContentBlockedWithDetail)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DidUseKeygen, OnDidUseKeygen)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void TabSpecificContentSettings::DidStartNavigation(
-    content::NavigationHandle* navigation_handle) {
-  if (!navigation_handle->IsInMainFrame() || navigation_handle->IsSamePage())
+void TabSpecificContentSettings::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  if (!details.is_in_page) {
+    // Clear "blocked" flags.
+    ClearContentSettingsExceptForNavigationRelatedSettings();
+    blocked_plugin_names_.clear();
+    GeolocationDidNavigate(details);
+    MidiDidNavigate(details);
+
+    if (web_contents()->GetVisibleURL().SchemeIsHTTPOrHTTPS()) {
+      content_settings::RecordPluginsAction(
+          content_settings::PLUGINS_ACTION_TOTAL_NAVIGATIONS);
+    }
+  }
+}
+
+void TabSpecificContentSettings::DidStartProvisionalLoadForFrame(
+    content::RenderFrameHost* render_frame_host,
+    const GURL& validated_url,
+    bool is_error_page,
+    bool is_iframe_srcdoc) {
+  if (render_frame_host->GetParent())
     return;
 
-  const content::NavigationController& controller =
-      web_contents()->GetController();
-  content::NavigationEntry* last_committed_entry =
-      controller.GetLastCommittedEntry();
-  if (last_committed_entry)
-    previous_url_ = last_committed_entry->GetURL();
-
   // If we're displaying a network error page do not reset the content
   // settings delegate's cookies so the user has a chance to modify cookie
   // settings.
-  if (!navigation_handle->IsErrorPage())
+  if (!is_error_page)
     ClearNavigationRelatedContentSettings();
   ClearGeolocationContentSettings();
   ClearMidiContentSettings();
   ClearPendingProtocolHandler();
 }
 
-void TabSpecificContentSettings::DidFinishNavigation(
-      content::NavigationHandle* navigation_handle) {
-  if (!navigation_handle->IsInMainFrame() ||
-      !navigation_handle->HasCommitted() ||
-      navigation_handle->IsSamePage()) {
-    return;
-  }
-
-  // Clear "blocked" flags.
-  ClearContentSettingsExceptForNavigationRelatedSettings();
-  blocked_plugin_names_.clear();
-  GeolocationDidNavigate(navigation_handle);
-  MidiDidNavigate(navigation_handle);
-
-  if (web_contents()->GetVisibleURL().SchemeIsHTTPOrHTTPS()) {
-    content_settings::RecordPluginsAction(
-        content_settings::PLUGINS_ACTION_TOTAL_NAVIGATIONS);
-  }
-}
-
 void TabSpecificContentSettings::AppCacheAccessed(const GURL& manifest_url,
                                                   bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
@@ skipping 14 matching lines @@
 
 void TabSpecificContentSettings::ClearGeolocationContentSettings() {
   geolocation_usages_state_.ClearStateMap();
 }
 
 void TabSpecificContentSettings::ClearMidiContentSettings() {
   midi_usages_state_.ClearStateMap();
 }
 
 void TabSpecificContentSettings::GeolocationDidNavigate(
-    content::NavigationHandle* navigation_handle) {
-  ContentSettingsUsagesState::CommittedDetails committed_details;
-  committed_details.current_url = navigation_handle->GetURL();
-  committed_details.previous_url = previous_url_;
-
-  geolocation_usages_state_.DidNavigate(committed_details);
+    const content::LoadCommittedDetails& details) {
+  geolocation_usages_state_.DidNavigate(GetCommittedDetails(details));
 }
 
 void TabSpecificContentSettings::MidiDidNavigate(
-    content::NavigationHandle* navigation_handle) {
-  ContentSettingsUsagesState::CommittedDetails committed_details;
-  committed_details.current_url = navigation_handle->GetURL();
-  committed_details.previous_url = previous_url_;
-  midi_usages_state_.DidNavigate(committed_details);
+    const content::LoadCommittedDetails& details) {
+  midi_usages_state_.DidNavigate(GetCommittedDetails(details));
 }
 
 void TabSpecificContentSettings::BlockAllContentForTesting() {
   content_settings::ContentSettingsRegistry* registry =
       content_settings::ContentSettingsRegistry::GetInstance();
   for (const content_settings::ContentSettingsInfo* info : *registry) {
     ContentSettingsType type = info->website_settings_info()->type();
     if (type != CONTENT_SETTINGS_TYPE_GEOLOCATION &&
         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
       OnContentBlocked(type);
     }
   }
 
   // Geolocation and media must be blocked separately, as the generic
   // TabSpecificContentSettings::OnContentBlocked does not apply to them.
   OnGeolocationPermissionSet(web_contents()->GetLastCommittedURL(), false);
   MicrophoneCameraStateFlags media_blocked =
       static_cast<MicrophoneCameraStateFlags>(
           TabSpecificContentSettings::MICROPHONE_ACCESSED |
           TabSpecificContentSettings::MICROPHONE_BLOCKED |
           TabSpecificContentSettings::CAMERA_ACCESSED |
           TabSpecificContentSettings::CAMERA_BLOCKED);
   OnMediaStreamPermissionSet(
       web_contents()->GetLastCommittedURL(),
       media_blocked,
       std::string(), std::string(), std::string(), std::string());
 }