Fix managed mode allow/block flow

chrome/browser/managed_mode/managed_mode_navigation_observer.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/managed_mode/managed_mode_navigation_observer.h"
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 245 matching lines @@
 
 ManagedModeNavigationObserver::~ManagedModeNavigationObserver() {
   RemoveTemporaryException();
 }
 
 ManagedModeNavigationObserver::ManagedModeNavigationObserver(
     content::WebContents* web_contents)
     : WebContentsObserver(web_contents),
       warn_infobar_delegate_(NULL),
       preview_infobar_delegate_(NULL),
-      got_user_gesture_(false),
       state_(RECORDING_URLS_BEFORE_PREVIEW),
       is_elevated_(false),
-      last_allowed_page_(-1) {
+      last_allowed_page_(-1),
+      finished_redirects_(false) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   managed_user_service_ = ManagedUserServiceFactory::GetForProfile(profile);
   if (!managed_user_service_->ProfileIsManaged())
     is_elevated_ = true;
   url_filter_ = managed_user_service_->GetURLFilterForUIThread();
 }
 
 void ManagedModeNavigationObserver::AddTemporaryException() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(web_contents());
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ManagedModeResourceThrottle::AddTemporaryException,
                  web_contents()->GetRenderProcessHost()->GetID(),
                  web_contents()->GetRenderViewHost()->GetRoutingID(),
-                 last_url_,
-                 got_user_gesture_));
-}
-
-void ManagedModeNavigationObserver::UpdateExceptionNavigationStatus() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(web_contents());
-
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&ManagedModeResourceThrottle::UpdateExceptionNavigationStatus,
-                 web_contents()->GetRenderProcessHost()->GetID(),
-                 web_contents()->GetRenderViewHost()->GetRoutingID(),
-                 got_user_gesture_));
+                 last_url_));
 }
 
 void ManagedModeNavigationObserver::RemoveTemporaryException() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // When closing the browser web_contents() may return NULL so guard against
   // that.
   if (!web_contents())
     return;
 
   BrowserThread::PostTask(
@@ skipping 88 matching lines @@
 }
 
 void ManagedModeNavigationObserver::NavigateToPendingEntry(
     const GURL& url,
     content::NavigationController::ReloadType reload_type) {
   DVLOG(1) << "NavigateToPendingEntry " << url.spec();
   // This method gets called only when the user goes back and forward and when
   // the user types a new URL. So do the main work in
   // ProvisionalChangeToMainFrameUrl and only check that the user didn't go
   // back to a blocked site here.
-  if (web_contents()->GetController().GetCurrentEntryIndex() <
-      last_allowed_page_) {
+  ManagedModeURLFilter::FilteringBehavior behavior =
+      url_filter_->GetFilteringBehaviorForURL(url);
+  int current_index = web_contents()->GetController().GetCurrentEntryIndex();
+  // First check that the user didn't go back to a blocked page, then check
+  // that the navigation is allowed.
+  if (last_allowed_page_ < 0 || current_index <= last_allowed_page_ ||
+      (behavior == ManagedModeURLFilter::BLOCK &&
+       !CanTemporarilyNavigateHost(url))) {
     ClearObserverState();
   }
+  finished_redirects_ = false;
 }
 
 void ManagedModeNavigationObserver::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (!ShouldStayElevatedForURL(params.url))
     is_elevated_ = false;
+  DVLOG(1) << "DidNavigateMainFrame " << params.url.spec();
 
+  // The page already loaded so we are not redirecting anymore, so the
+  // next call to ProvisionalChangeToMainFrameURL will probably be after a
+  // click.
+  // TODO(sergiu): One case where I think this fails is if we get a client-side
+  // redirect to a different domain as that will not have a temporary
+  // exception. See about that in the future.
+  finished_redirects_ = true;
   content::RecordAction(UserMetricsAction("ManagedMode_MainFrameNavigation"));
 
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(params.url);
 
+  if (behavior == ManagedModeURLFilter::ALLOW) {
+    // Update the last allowed page so that we can go back to it.
+    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
+  }
+
   UMA_HISTOGRAM_ENUMERATION("ManagedMode.FilteringBehavior",
                             behavior,
                             ManagedModeURLFilter::HISTOGRAM_BOUNDING_VALUE);
 
-  // The page can be redirected to a different domain, record those URLs as
-  // well.
-  if (behavior == ManagedModeURLFilter::BLOCK &&
-      !CanTemporarilyNavigateHost(params.url))
-    AddURLToPatternList(params.url);
+  // Record all the URLs this navigation went through.
+  if ((behavior == ManagedModeURLFilter::ALLOW &&
+       state_ == RECORDING_URLS_AFTER_PREVIEW) ||
+      !CanTemporarilyNavigateHost(params.url)) {
+    for (std::vector<GURL>::const_iterator it = params.redirects.begin();
+         it != params.redirects.end(); ++it) {
+      DVLOG(1) << "Adding: " << it->spec();
+      AddURLToPatternList(*it);
+    }
+  }
 
   if (behavior == ManagedModeURLFilter::ALLOW &&
       state_ == RECORDING_URLS_AFTER_PREVIEW) {
     // The initial page that triggered the interstitial was blocked but the
     // final page is already in the whitelist so add the series of URLs
     // which lead to the final page to the whitelist as well.
-    // Update the |last_url_| since it was not added to the list before.
-    last_url_ = params.url;
     AddSavedURLsToWhitelistAndClearState();
+    // This page is now allowed so save the index as well.
+    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
     SimpleAlertInfoBarDelegate::Create(
         InfoBarService::FromWebContents(web_contents()),
         NULL,
         l10n_util::GetStringUTF16(IDS_MANAGED_MODE_ALREADY_ADDED_MESSAGE),
         true);
     return;
   }
 
   // Update the exception to the last host visited. A redirect can follow this
   // so don't update the state yet.
   if (state_ == RECORDING_URLS_AFTER_PREVIEW) {
     AddTemporaryException();
   }
-
-  // The navigation is complete, unless there is a redirect. So set the
-  // new navigation to false to detect user interaction.
-  got_user_gesture_ = false;
 }
 
 void ManagedModeNavigationObserver::ProvisionalChangeToMainFrameUrl(
     const GURL& url,
     content::RenderViewHost* render_view_host) {
   if (!ShouldStayElevatedForURL(url))
     is_elevated_ = false;
 
   // This function is the last one to be called before the resource throttle
   // shows the interstitial if the URL must be blocked.
   DVLOG(1) << "ProvisionalChangeToMainFrameURL " << url.spec();
+
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(url);
-
   if (behavior != ManagedModeURLFilter::BLOCK)
     return;
 
-  if (state_ == RECORDING_URLS_AFTER_PREVIEW && got_user_gesture_ &&
+  if (finished_redirects_ && state_ == RECORDING_URLS_AFTER_PREVIEW &&
       !CanTemporarilyNavigateHost(url))
     ClearObserverState();
-
-  if (behavior == ManagedModeURLFilter::BLOCK &&
-      !CanTemporarilyNavigateHost(url))
-    AddURLToPatternList(url);
-
-  got_user_gesture_ = false;
 }
 
 void ManagedModeNavigationObserver::DidCommitProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& url,
     content::PageTransition transition_type,
     content::RenderViewHost* render_view_host) {
   if (!is_main_frame)
     return;
@@ skipping 17 matching lines @@
   }
 
   if (behavior == ManagedModeURLFilter::BLOCK) {
     DCHECK_EQ(RECORDING_URLS_AFTER_PREVIEW, state_);
     // Add the infobar.
     if (!preview_infobar_delegate_) {
       preview_infobar_delegate_ = ManagedModePreviewInfobarDelegate::Create(
           InfoBarService::FromWebContents(web_contents()));
     }
   }
-
-  if (behavior == ManagedModeURLFilter::ALLOW)
-    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
 }
-
-void ManagedModeNavigationObserver::DidGetUserGesture() {
-  got_user_gesture_ = true;
-  // Update the exception status so that the resource throttle knows that
-  // there was a manual navigation.
-  UpdateExceptionNavigationStatus();
-}