Add elevation to the managed mode navigation observer.

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"
+#include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/infobars/confirm_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/infobars/simple_alert_infobar_delegate.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/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/extensions/extension_constants.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/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "grit/generated_resources.h"
@@ skipping 218 matching lines @@
   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) {
   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,
@@ skipping 54 matching lines @@
       urls, ManagedUserService::MANUAL_ALLOW);
   if (last_url_.is_valid()) {
     std::vector<std::string> hosts;
     hosts.push_back(last_url_.host());
     managed_user_service_->SetManualBehaviorForHosts(
         hosts, ManagedUserService::MANUAL_ALLOW);
   }
   ClearObserverState();
 }
 
+bool ManagedModeNavigationObserver::is_elevated() const {
+  return is_elevated_;
+}
+
+void ManagedModeNavigationObserver::set_elevated(bool is_elevated) {
+  is_elevated_ = is_elevated;
+}
+
 void ManagedModeNavigationObserver::AddURLToPatternList(const GURL& url) {
   navigated_urls_.insert(url);
   last_url_ = url;
 }
 
 void ManagedModeNavigationObserver::SetStateToRecordingAfterPreview() {
   state_ = RECORDING_URLS_AFTER_PREVIEW;
 }
 
 bool ManagedModeNavigationObserver::CanTemporarilyNavigateHost(
     const GURL& url) {
   return last_url_.host() == url.host();
 }
 
+bool ManagedModeNavigationObserver::ShouldStayElevatedForURL(
+    const GURL& navigation_url) {
+  std::string url = navigation_url.spec();
+  // Handle chrome:// URLs specially.
+  if (navigation_url.host() == "chrome") {
+    // The path contains the actual host name, but starts with a "/". Remove
+    // the "/".
+    url = navigation_url.path().substr(1);
+  }
+
+  // Check if any of the special URLs is a prefix of |url|.
+  return StartsWithASCII(url, chrome::kChromeUIHistoryHost, false) ||
+         StartsWithASCII(url, chrome::kChromeUIExtensionsHost, false) ||
+         StartsWithASCII(url, chrome::kChromeUISettingsHost, false) ||
+         StartsWithASCII(url, extension_urls::kGalleryBrowsePrefix, false);
+}
+
 void ManagedModeNavigationObserver::ClearObserverState() {
   if (preview_infobar_delegate_) {
     InfoBarService* infobar_service =
         InfoBarService::FromWebContents(web_contents());
     infobar_service->RemoveInfoBar(preview_infobar_delegate_);
     preview_infobar_delegate_ = NULL;
   }
   navigated_urls_.clear();
   last_url_ = GURL();
   state_ = RECORDING_URLS_BEFORE_PREVIEW;
@@ skipping 12 matching lines @@
   // back to a blocked site here.
   if (web_contents()->GetController().GetCurrentEntryIndex() <
       last_allowed_page_) {
     ClearObserverState();
   }
 }
 
 void ManagedModeNavigationObserver::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
+  if (!ShouldStayElevatedForURL(params.url))
+    is_elevated_ = false;
 
   content::RecordAction(UserMetricsAction("ManagedMode_MainFrameNavigation"));
 
   ManagedModeURLFilter::FilteringBehavior behavior =
       url_filter_->GetFilteringBehaviorForURL(params.url);
 
   UMA_HISTOGRAM_ENUMERATION("ManagedMode.FilteringBehavior",
                             behavior,
                             ManagedModeURLFilter::HISTOGRAM_BOUNDING_VALUE);
 
@@ skipping 23 matching lines @@
   // 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::DidStartProvisionalLoadForFrame(
-    int64 frame_id,
-    int64 parent_frame_id,
-    bool is_main_frame,
-    const GURL& validated_url,
-    bool is_error_page,
-    bool is_iframe_srcdoc,
-    content::RenderViewHost* render_view_host) {
-  if (!is_main_frame)
-    return;
-}
-
 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_ &&
@@ skipping 46 matching lines @@
   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();
 }