Support manual (white|black)list, previewing and allowing after interstitial

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/string_number_conversions.h"
 #include "chrome/browser/api/infobars/simple_alert_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/managed_mode/managed_mode.h"
 #include "chrome/browser/managed_mode/managed_mode_interstitial.h"
+#include "chrome/browser/managed_mode/managed_mode_resource_throttle.h"
 #include "chrome/browser/managed_mode/managed_mode_url_filter.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using content::BrowserThread;
+
 namespace {
 
-bool IsInList(const ListValue *list, const std::string& url_to_add) {
-  return list->Find(*Value::CreateStringValue(url_to_add)) != list->end();
-}
-
 class ManagedModeWarningInfobarDelegate : public ConfirmInfoBarDelegate {
  public:
   explicit ManagedModeWarningInfobarDelegate(
       InfoBarTabHelper* infobar_tab_helper,
       int last_allowed_page);
 
  private:
   virtual ~ManagedModeWarningInfobarDelegate();
 
   // ConfirmInfoBarDelegate overrides:
@@ skipping 107 matching lines @@
 }
 
 int ManagedModePreviewInfobarDelegate::GetButtons() const {
   return BUTTON_OK | BUTTON_CANCEL;
 }
 
 string16 ManagedModePreviewInfobarDelegate::GetButtonLabel(
     InfoBarButton button) const {
   return l10n_util::GetStringUTF16(
       (button == BUTTON_OK) ? IDS_MANAGED_MODE_PREVIEW_ACCEPT
-                            : IDS_MANAGED_MODE_PREVIEW_CANCEL);
+                            : IDS_MANAGED_MODE_GO_BACK_ACTION);
 }
 
 bool ManagedModePreviewInfobarDelegate::Accept() {
   ManagedModeNavigationObserver* observer =
       ManagedModeNavigationObserver::FromWebContents(
           owner()->GetWebContents());
-  observer->AddURLList();
-  // Clear the pointer as the infobar was closed.
-  observer->PreviewInfobarDismissed();
+  observer->AddSavedURLsToWhitelist();
+  // Notify the navigation observer that the infobar was dismissed.
+  observer->ClearObserverState();
 
   return true;
 }
 
 bool ManagedModePreviewInfobarDelegate::Cancel() {
   // TODO(bauerb): Go back to the last page.
+  ManagedModeNavigationObserver* observer =
+      ManagedModeNavigationObserver::FromWebContents(
+          owner()->GetWebContents());
+  observer->ClearObserverState();
   return false;
 }
 
 bool ManagedModePreviewInfobarDelegate::ShouldExpire(
     const content::LoadCommittedDetails& details) const {
   // ManagedModeNavigationObserver removes us below.
   return false;
 }
 
 void ManagedModePreviewInfobarDelegate::InfoBarDismissed() {
   ManagedModeNavigationObserver* observer =
       ManagedModeNavigationObserver::FromWebContents(
           owner()->GetWebContents());
   observer->PreviewInfobarDismissed();
 }
 
 }  // namespace
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ManagedModeNavigationObserver)
 
-ManagedModeNavigationObserver::~ManagedModeNavigationObserver() {}
+ManagedModeNavigationObserver::~ManagedModeNavigationObserver() {
+  RemoveTemporaryException();
+}
 
 ManagedModeNavigationObserver::ManagedModeNavigationObserver(
     content::WebContents* web_contents)
     : WebContentsObserver(web_contents),
       url_filter_(ManagedMode::GetURLFilterForUIThread()),
+      state_(RECORDING_URLS_BEFORE_PREVIEW),

[Bernhard Bauer, 2012/11/27 18:44:46]

Ohhhh! I was assuming that "not recording" is the default state. What do we
record in this state?

[Sergiu, 2012/11/28 12:53:25]

By default we record all the URLs that are blacklisted until we hit an
interstitial. After the user clicks "Preview" we still record all redirects that
would be blacklisted and once they are complete we do not record any more.

       warn_infobar_delegate_(NULL),
       preview_infobar_delegate_(NULL),
-      after_interstitial_(false),
       last_allowed_page_(-1) {}
 
+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(),
+                 navigated_urls_.back().host()));
+}
+
+void ManagedModeNavigationObserver::RemoveTemporaryException() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!web_contents())

[Bernhard Bauer, 2012/11/27 18:44:46]

Can you add a comment to explain when web_contents() might be NULL?

[Sergiu, 2012/11/28 12:53:25]

Done.

+    return;
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ManagedModeResourceThrottle::RemoveTemporaryException,
+                 web_contents()->GetRenderProcessHost()->GetID(),
+                 web_contents()->GetRenderViewHost()->GetRoutingID()));
+}
+
 void ManagedModeNavigationObserver::WarnInfobarDismissed() {
   DCHECK(warn_infobar_delegate_);
   warn_infobar_delegate_ = NULL;
 }
 
 void ManagedModeNavigationObserver::PreviewInfobarDismissed() {
   DCHECK(preview_infobar_delegate_);
   preview_infobar_delegate_ = NULL;
 }
 
-void ManagedModeNavigationObserver::AddNavigatedURL(const GURL& url) {
-  if (std::find(navigated_urls_.begin(), navigated_urls_.end(), url) !=
-      navigated_urls_.end()) {
-    navigated_urls_.push_back(url);
-  }
-}
+void ManagedModeNavigationObserver::AddSavedURLsToWhitelist() {
+  // |whitelist| is used to add the URLs to the preference list while
+  // AddURLPatternToManualWhitelist adds the navigated urls to the URL filter.
+  base::ListValue whitelist;
+  std::string pattern_to_add;
+  bool added_urls = false;
 
-void ManagedModeNavigationObserver::AddURLList() {
-  // Get a copy of the whitelist since it can't be edited in place.
-  // |whitelist| is the preference list while AddStringToManualWhitelist adds
-  // the navigated urls to the URL filter.
-  scoped_ptr<base::ListValue> whitelist(
-      ManagedMode::GetWhitelist()->DeepCopy());
-  std::string url_to_add;
-  int added_url_count = 0;
+  if (!navigated_urls_.empty()) {
+    for (std::vector<GURL>::const_iterator it = navigated_urls_.begin();
+         it+1 != navigated_urls_.end(); ++it) {
+      GURL current_url = *it;
+      GURL::Replacements replaced_components;
+      // Add the . to match the exact host.
+      replaced_components.SetHostStr("." + it->host());
+      replaced_components.SetRefStr("");
+      replaced_components.SetSchemeStr("");
+      current_url.ReplaceComponents(replaced_components);
+      pattern_to_add = current_url.spec();
+      whitelist.AppendString(pattern_to_add);
+    }
 
-  for (std::vector<GURL>::const_iterator it = navigated_urls_.begin();
-       it+1 != navigated_urls_.end(); ++it) {
-    url_to_add = it->spec();
-    if (!IsInList(ManagedMode::GetWhitelist().get(), url_to_add)) {
-      DLOG(ERROR) << "Adding (exact):" << url_to_add;
-      ManagedMode::AddStringToManualWhitelist(url_to_add);
-      whitelist->Append(Value::CreateStringValue(url_to_add));
-      ++added_url_count;
+    // Add the protocol as well if the URL uses HTTPS. Also, since this is the
+    // final destination, add the whole subdomain.
+    if (navigated_urls_.back().SchemeIs("https")) {
+      pattern_to_add = "https://" + navigated_urls_.back().host();
+    } else {
+      pattern_to_add = navigated_urls_.back().host();
     }
+
+    whitelist.AppendString(pattern_to_add);
+
+    added_urls = ManagedMode::AddToManualWhitelist(whitelist);
   }
 
-  // If the URL uses https add the protocol as well instead of just the
-  // hostname.
-  if (navigated_urls_.back().SchemeIs("https")) {
-    url_to_add = navigated_urls_.back().GetOrigin().spec();
-  } else {
-    url_to_add = navigated_urls_.back().host();
-  }
-
-  // Use the local whitelist to see if this last URL is already there.
-  if (!IsInList(ManagedMode::GetWhitelist().get(), url_to_add)) {
-    DLOG(ERROR) << "Adding (hostname): " << url_to_add;
-    ManagedMode::AddStringToManualWhitelist(url_to_add);
-    whitelist->Append(Value::CreateStringValue(url_to_add));
-    ++added_url_count;
-  } else {
+  if ((navigated_urls_.empty() || !added_urls) &&
+      state_ != RECORDING_URLS_BEFORE_PREVIEW) {

[Bernhard Bauer, 2012/11/27 18:44:46]

So, IIUC we have multiple entry points to this method (accepting the infobar,
and ending up on a page that's already allowed), and then we use this check to
distinguish them again, because we only want to show the message in the latter
case. Couldn't we just do that at the call site instead?

[Sergiu, 2012/11/28 12:53:25]

It should work, yes, I've refactored and simplified a bit, moved the infobar
call in the call site.

     // Tell the user that the site was already present in the whitelist.
     InfoBarTabHelper* infobar_tab_helper =
         InfoBarTabHelper::FromWebContents(web_contents());
     infobar_tab_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
         infobar_tab_helper,
         NULL,
-        l10n_util::GetStringFUTF16(IDS_MANAGED_MODE_ALREADY_ADDED_MESSAGE,
-                                   base::IntToString16(added_url_count)),
+        l10n_util::GetStringUTF16(IDS_MANAGED_MODE_ALREADY_ADDED_MESSAGE),
         true));
   }
 
-  ManagedMode::SetWhitelist(whitelist.get());
+}
+void ManagedModeNavigationObserver::SaveNavigatedURL(const GURL& url) {
+  if (state_ == NOT_RECORDING_URLS)
+    return;
+
+  if (std::find(navigated_urls_.begin(), navigated_urls_.end(), url) ==
+      navigated_urls_.end()) {
+    navigated_urls_.push_back(url);
+  }
+}
+
+
+void ManagedModeNavigationObserver::SetStateToRecordingAfterPreview() {
+  state_ = RECORDING_URLS_AFTER_PREVIEW;
+}
+
+void ManagedModeNavigationObserver::ClearObserverState() {
+  if (state_ == NOT_RECORDING_URLS && preview_infobar_delegate_) {
+    InfoBarTabHelper* infobar_tab_helper =
+        InfoBarTabHelper::FromWebContents(web_contents());
+    infobar_tab_helper->RemoveInfoBar(preview_infobar_delegate_);
+    preview_infobar_delegate_ = NULL;
+  }
+  navigated_urls_.clear();
+  state_ = RECORDING_URLS_BEFORE_PREVIEW;
+  RemoveTemporaryException();
 }
 
 void ManagedModeNavigationObserver::NavigateToPendingEntry(
     const GURL& url,
     content::NavigationController::ReloadType reload_type) {
   DLOG(ERROR) << "NavigateToPendingEntry: " << url;
-  // This means that a new navigation was instantiated and the data related to
-  // the list of URLs needs to be cleared.
-  navigated_urls_.clear();
-  after_interstitial_ = false;
+
+  // This method gets called first when a user navigates to a (new) URL.
+  // This means that the data related to the list of URLs needs to be cleared
+  // in certain circumstances.
+  if (web_contents()->GetController().GetCurrentEntryIndex() <
+      last_allowed_page_ ||
+      navigated_urls_.empty() ||
+      navigated_urls_.back().host() != url.host()) {
+    ClearObserverState();
+  }
 }
 
 void ManagedModeNavigationObserver::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DLOG(ERROR) << "DidNavigateMainFrame: " << params.url;
 
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(params.url);
 
-  if (behavior != ManagedModeURLFilter::ALLOW)
-    AddNavigatedURL(params.url);
+  if (state_ != NOT_RECORDING_URLS)
+    SaveNavigatedURL(params.url);
 
-  if (behavior == ManagedModeURLFilter::ALLOW && after_interstitial_) {
+  if (behavior == ManagedModeURLFilter::ALLOW &&
+      state_ != RECORDING_URLS_BEFORE_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.
-    AddURLList();
+    AddSavedURLsToWhitelist();
+  }
+  if (state_ == RECORDING_URLS_AFTER_PREVIEW) {
+    state_ = NOT_RECORDING_URLS;
+    AddTemporaryException();
   }
 }
 
 void ManagedModeNavigationObserver::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     int64 parent_frame_id,
     bool is_main_frame,
     const GURL& url,
     bool is_error_page,
     content::RenderViewHost* render_view_host) {
   if (!is_main_frame)
     return;
 
   DLOG(ERROR) << "DidStartProvisionalLoadForFrame: " << url;
 }
 
 void ManagedModeNavigationObserver::ProvisionalChangeToMainFrameUrl(
     const GURL& url,
     const GURL& opener_url,
     content::RenderViewHost* render_view_host) {
   DLOG(ERROR) << "ProvisionalChangeToMainFrameUrl: " << url;
-  // Mark the fact that an interstitial will be triggered here if the URL
-  // must be blocked.
+  // This function is the last one to be called before the resource throttle
+  // shows the interstitial if the URL must be blocked.
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(url);
-  if (behavior == ManagedModeURLFilter::BLOCK)
-    after_interstitial_ = true;
-  if (behavior != ManagedModeURLFilter::ALLOW)
-    AddNavigatedURL(url);
+
+  if (!navigated_urls_.empty() && state_ == NOT_RECORDING_URLS &&
+      navigated_urls_.back().host() != url.host())
+    ClearObserverState();
+
+  if (behavior != ManagedModeURLFilter::ALLOW && state_ != NOT_RECORDING_URLS)
+    SaveNavigatedURL(url);
 }
 
 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;
 
   DLOG(ERROR) << "DidCommitProvisionalLoadForFrame: " << url;
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(url);
 
-  DLOG(ERROR) << "Current behavior: " << behavior;
   if (behavior == ManagedModeURLFilter::WARN) {
     if (!warn_infobar_delegate_) {
       InfoBarTabHelper* infobar_tab_helper =
           InfoBarTabHelper::FromWebContents(web_contents());
       warn_infobar_delegate_ =
           new ManagedModeWarningInfobarDelegate(infobar_tab_helper,
                                                 last_allowed_page_);
       infobar_tab_helper->AddInfoBar(warn_infobar_delegate_);
     }
   } else {
     if (warn_infobar_delegate_) {
       InfoBarTabHelper* infobar_tab_helper =
           InfoBarTabHelper::FromWebContents(web_contents());
       infobar_tab_helper->RemoveInfoBar(warn_infobar_delegate_);
-      warn_infobar_delegate_= NULL;
+      warn_infobar_delegate_ = NULL;
     }
-    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
   }
 
-  if (behavior == ManagedModeURLFilter::BLOCK) {
+  if (state_ != RECORDING_URLS_BEFORE_PREVIEW &&
+      behavior == ManagedModeURLFilter::BLOCK) {
     if (!preview_infobar_delegate_) {
       InfoBarTabHelper* infobar_tab_helper =
           InfoBarTabHelper::FromWebContents(web_contents());
       preview_infobar_delegate_ =
           new ManagedModePreviewInfobarDelegate(infobar_tab_helper);
       infobar_tab_helper->AddInfoBar(preview_infobar_delegate_);
     }
   } else {
     if (preview_infobar_delegate_) {

[Bernhard Bauer, 2012/11/27 18:44:46]

Does this actually happen now or do we remove the infobar beforehand?

[Sergiu, 2012/11/28 12:53:25]

No, it should be already removed every time we clear the state. Removed this
part.

       InfoBarTabHelper* infobar_tab_helper =
           InfoBarTabHelper::FromWebContents(web_contents());
       infobar_tab_helper->RemoveInfoBar(preview_infobar_delegate_);
-      preview_infobar_delegate_= NULL;
+      preview_infobar_delegate_ = NULL;
     }
   }
+
+  if (behavior == ManagedModeURLFilter::ALLOW) {
+    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
+  }
 }