Fix content settings's cookie code to work with PlzNavigate.

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 20 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 "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 {
 
-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;
+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);
 }
 
 }  // 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(int render_process_id,
-                                             int render_frame_id,
-                                             const GURL& url,
-                                             const GURL& frame_url,
-                                             const net::CookieList& cookie_list,
-                                             bool blocked_by_policy) {
+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) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  TabSpecificContentSettings* settings =
-      GetForFrame(render_process_id, render_frame_id);
+  TabSpecificContentSettings* settings = GetForWCGetter(wc_getter);
   if (settings) {
     settings->OnCookiesRead(url, frame_url, cookie_list,
                             blocked_by_policy);
   }
 }
 
 // static
 void TabSpecificContentSettings::CookieChanged(
-    int render_process_id,
-    int render_frame_id,
+    const base::Callback<WebContents*(void)>& wc_getter,
     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 =
-      GetForFrame(render_process_id, render_frame_id);
+  TabSpecificContentSettings* settings = GetForWCGetter(wc_getter);
   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 598 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::DidNavigateMainFrame(
-    const content::LoadCommittedDetails& details,
-    const content::FrameNavigateParams& params) {
-  if (!details.is_in_page) {
-    // Clear "blocked" flags.
-    ClearBlockedContentSettingsExceptForCookies();
-    blocked_plugin_names_.clear();
-    GeolocationDidNavigate(details);
-    MidiDidNavigate(details);
+void TabSpecificContentSettings::DidStartNavigation(
+    content::NavigationHandle* navigation_handle) {
+  if (!navigation_handle->IsInMainFrame())
+    return;
 
-    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 (!is_error_page)
+  if (!navigation_handle->IsErrorPage())
     ClearCookieSpecificContentSettings();
   ClearGeolocationContentSettings();
   ClearMidiContentSettings();
   ClearPendingProtocolHandler();
 }
 
+void TabSpecificContentSettings::DidFinishNavigation(
+      content::NavigationHandle* navigation_handle) {
+  if (!navigation_handle->IsInMainFrame() ||
+      !navigation_handle->HasCommitted() ||
+      navigation_handle->IsSamePage()) {
+    return;
+  }
+
+  // Clear "blocked" flags.
+  ClearBlockedContentSettingsExceptForCookies();
+  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(
-    const content::LoadCommittedDetails& details) {
-  geolocation_usages_state_.DidNavigate(GetCommittedDetails(details));
+    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);
 }
 
 void TabSpecificContentSettings::MidiDidNavigate(
-    const content::LoadCommittedDetails& details) {
-  midi_usages_state_.DidNavigate(GetCommittedDetails(details));
+    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);
 }
 
 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());
 }