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->AddSavedURLsToWhitelistAndClearState();
   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();
 }
 
+// Taken from shill_manager_client.cc as ListValue returns a const_iterator
+// in its Find method.
+struct ValueEquals {
+  explicit ValueEquals(const Value* first) : first_(first) {}
+  bool operator()(const Value* second) const {
+    return first_->Equals(second);
+  }
+  const Value* first_;
+};
+
 }  // 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()),
       warn_infobar_delegate_(NULL),
       preview_infobar_delegate_(NULL),
-      after_interstitial_(false),
+      state_(RECORDING_URLS_BEFORE_PREVIEW),
       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(),
+                 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(
+      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::AddSavedURLsToWhitelistAndClearState() {
+  ListValue whitelist;
+  for (std::set<GURL>::const_iterator it = navigated_urls_.begin();
+       it != navigated_urls_.end();
+       ++it) {
+    whitelist.AppendString(it->scheme() + "://." + it->host());
   }
+  if (last_url_.is_valid()) {
+    if (last_url_.SchemeIs("https")) {
+      whitelist.AppendString("https://" + last_url_.host());
+    } else {
+      whitelist.AppendString(last_url_.host());
+    }
+  }
+  ManagedMode::AddToManualWhitelist(whitelist);
+  ClearObserverState();
 }
 
-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;
+void ManagedModeNavigationObserver::AddURLToPatternList(const GURL& url) {
+  DCHECK(state_ != NOT_RECORDING_URLS);
+  navigated_urls_.insert(url);
+}
 
-  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;
-    }
+void ManagedModeNavigationObserver::AddURLAsLastPattern(const GURL& url) {
+  DCHECK(state_ != NOT_RECORDING_URLS);
+
+  // Erase the last |url| if it is present in the |navigated_urls_|. This stops
+  // us from having both http://.www.google.com (exact URL from the pattern
+  // list) and www.google.com (hostname from the last URL pattern) in the list.
+  navigated_urls_.erase(url);
+  last_url_ = url;
+}
+
+void ManagedModeNavigationObserver::SetStateToRecordingAfterPreview() {
+  state_ = RECORDING_URLS_AFTER_PREVIEW;
+}
+
+bool ManagedModeNavigationObserver::CanTemporarilyNavigateHost(
+    const GURL& url) {
+  if (last_url_.scheme() == "https") {
+    return url.scheme() == "https" && last_url_.host() == url.host();
   }
+  return last_url_.host() == url.host();
+}
 
-  // 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 {
-    // Tell the user that the site was already present in the whitelist.
+void ManagedModeNavigationObserver::ClearObserverState() {
+  if (state_ == NOT_RECORDING_URLS && preview_infobar_delegate_) {
     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)),
-        true));
+    infobar_tab_helper->RemoveInfoBar(preview_infobar_delegate_);
+    preview_infobar_delegate_ = NULL;
   }
-
-  ManagedMode::SetWhitelist(whitelist.get());
+  navigated_urls_.clear();
+  last_url_ = GURL();
+  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_ || !CanTemporarilyNavigateHost(url)) {
+    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 the user just saw an interstitial this is the final URL so it is
+  // recorded. Checking for filtering behavior here isn't useful because
+  // although this specific URL can be allowed the hostname will be added which
+  // is more general. The hostname will be checked later when it is
+  // added to the actual whitelist to see if it is already present.
+  if (behavior == ManagedModeURLFilter::BLOCK && state_ != NOT_RECORDING_URLS)
+    AddURLAsLastPattern(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();
+    AddSavedURLsToWhitelistAndClearState();
+    InfoBarTabHelper* infobar_tab_helper =
+        InfoBarTabHelper::FromWebContents(web_contents());
+    infobar_tab_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
+        infobar_tab_helper,
+        NULL,
+        l10n_util::GetStringUTF16(IDS_MANAGED_MODE_ALREADY_ADDED_MESSAGE),
+        true));
+    return;
+  }
+
+  if (state_ == RECORDING_URLS_AFTER_PREVIEW) {
+    // A temporary exception should be added only if an interstitial was shown,
+    // the user clicked preview and the final page was not allowed. This
+    // temporary exception stops the interstitial from showing on further
+    // navigations to that host so that the user can navigate around to
+    // inspect it.
+    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 (state_ == NOT_RECORDING_URLS && !CanTemporarilyNavigateHost(url))
+    ClearObserverState();
+
+  if (behavior == ManagedModeURLFilter::BLOCK && state_ != NOT_RECORDING_URLS)
+    AddURLToPatternList(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_ == NOT_RECORDING_URLS)
+    DCHECK(preview_infobar_delegate_);
+  if (behavior == ManagedModeURLFilter::BLOCK)
+    DCHECK(state_ != RECORDING_URLS_BEFORE_PREVIEW);
+  if (state_ == RECORDING_URLS_AFTER_PREVIEW &&
+      behavior == ManagedModeURLFilter::BLOCK) {

[Bernhard Bauer, 2012/12/04 15:50:31]

Can you restructure this into one big switch statement on the |state_| (inside
of the behavior check)?

[Sergiu, 2012/12/04 16:25:24]

Done.

     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_) {
-      InfoBarTabHelper* infobar_tab_helper =
-          InfoBarTabHelper::FromWebContents(web_contents());
-      infobar_tab_helper->RemoveInfoBar(preview_infobar_delegate_);
-      preview_infobar_delegate_= NULL;
-    }
+  }
+
+  if (behavior == ManagedModeURLFilter::ALLOW) {
+    last_allowed_page_ = web_contents()->GetController().GetCurrentEntryIndex();
   }
 }