chrome/browser/supervised_user/supervised_user_interstitial.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/supervised_user/supervised_user_interstitial.h"
   6
   7 #include "base/memory/weak_ptr.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/infobars/infobar_service.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/supervised_user/supervised_user_service.h"
  16 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
  17 #include "chrome/common/pref_names.h"
  18 #include "chrome/grit/generated_resources.h"
  19 #include "components/infobars/core/infobar.h"
  20 #include "components/infobars/core/infobar_delegate.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "content/public/browser/interstitial_page.h"
  23 #include "content/public/browser/navigation_controller.h"
  24 #include "content/public/browser/navigation_details.h"
  25 #include "content/public/browser/navigation_entry.h"
  26 #include "content/public/browser/web_contents.h"
  27 #include "content/public/browser/web_contents_user_data.h"
  28 #include "content/public/browser/web_ui.h"
  29 #include "grit/browser_resources.h"
  30 #include "ui/base/l10n/l10n_util.h"
  31 #include "ui/base/resource/resource_bundle.h"
  32 #include "ui/base/webui/jstemplate_builder.h"
  33 #include "ui/base/webui/web_ui_util.h"
  34
  35 #if !defined(OS_ANDROID)
  36 #include "chrome/browser/ui/browser_finder.h"
  37 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  38 #endif
  39
  40 using content::BrowserThread;
  41 using content::WebContents;
  42
  43 namespace {
  44
  45 static const int kAvatarSize1x = 45;
  46 static const int kAvatarSize2x = 90;
  47
  48 std::string BuildAvatarImageUrl(const std::string& url, int size) {
  49   std::string result = url;
  50   size_t slash = result.rfind('/');
  51   if (slash != std::string::npos)
  52     result.insert(slash, "/s" + base::IntToString(size));
  53   return result;
  54 }
  55
  56 class TabCloser : public content::WebContentsUserData<TabCloser> {
  57   // To use, call TabCloser::CreateForWebContents.
  58  private:
  59   friend class content::WebContentsUserData<TabCloser>;
  60
  61   explicit TabCloser(WebContents* web_contents)
  62       : web_contents_(web_contents), weak_ptr_factory_(this) {
  63     BrowserThread::PostTask(
  64         BrowserThread::UI,
  65         FROM_HERE,
  66         base::Bind(&TabCloser::CloseTabImpl, weak_ptr_factory_.GetWeakPtr()));
  67   }
  68   virtual ~TabCloser() {}
  69
  70   void CloseTabImpl() {
  71     // On Android, FindBrowserWithWebContents and TabStripModel don't exist.
  72 #if !defined(OS_ANDROID)
  73     Browser* browser = chrome::FindBrowserWithWebContents(web_contents_);
  74     DCHECK(browser);
  75     TabStripModel* tab_strip = browser->tab_strip_model();
  76     DCHECK_NE(TabStripModel::kNoTab,
  77               tab_strip->GetIndexOfWebContents(web_contents_));
  78     if (tab_strip->count() <= 1) {
  79       // Don't close the last tab in the window.
  80       web_contents_->RemoveUserData(UserDataKey());
  81       return;
  82     }
  83 #endif
  84     web_contents_->Close();
  85   }
  86
  87   WebContents* web_contents_;
  88   base::WeakPtrFactory<TabCloser> weak_ptr_factory_;
  89 };
  90
  91 }  // namespace
  92
  93 DEFINE_WEB_CONTENTS_USER_DATA_KEY(TabCloser);
  94
  95 // static
  96 void SupervisedUserInterstitial::Show(
  97     WebContents* web_contents,
  98     const GURL& url,
  99     const base::Callback<void(bool)>& callback) {
 100   SupervisedUserInterstitial* interstitial =
 101       new SupervisedUserInterstitial(web_contents, url, callback);
 102
 103   // If Init() does not complete fully, immediately delete the interstitial.
 104   if (!interstitial->Init())
 105     delete interstitial;
 106   // Otherwise |interstitial_page_| is responsible for deleting it.
 107 }
 108
 109 SupervisedUserInterstitial::SupervisedUserInterstitial(
 110     WebContents* web_contents,
 111     const GURL& url,
 112     const base::Callback<void(bool)>& callback)
 113     : web_contents_(web_contents),
 114       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
 115       interstitial_page_(NULL),
 116       url_(url),
 117       callback_(callback),
 118       weak_ptr_factory_(this) {}
 119
 120 SupervisedUserInterstitial::~SupervisedUserInterstitial() {
 121   DCHECK(!web_contents_);
 122 }
 123
 124 bool SupervisedUserInterstitial::Init() {
 125   if (ShouldProceed()) {
 126     // It can happen that the site was only allowed very recently and the URL
 127     // filter on the IO thread had not been updated yet. Proceed with the
 128     // request without showing the interstitial.
 129     DispatchContinueRequest(true);
 130     return false;
 131   }
 132
 133   InfoBarService* service = InfoBarService::FromWebContents(web_contents_);
 134   if (service) {
 135     // Remove all the infobars which are attached to |web_contents_| and for
 136     // which ShouldExpire() returns true.
 137     content::LoadCommittedDetails details;
 138     // |details.is_in_page| is default false, and |details.is_main_frame| is
 139     // default true. This results in is_navigation_to_different_page() returning
 140     // true.
 141     DCHECK(details.is_navigation_to_different_page());
 142     const content::NavigationController& controller =
 143         web_contents_->GetController();
 144     details.entry = controller.GetActiveEntry();
 145     if (controller.GetLastCommittedEntry()) {
 146       details.previous_entry_index = controller.GetLastCommittedEntryIndex();
 147       details.previous_url = controller.GetLastCommittedEntry()->GetURL();
 148     }
 149     details.type = content::NAVIGATION_TYPE_NEW_PAGE;
 150     for (int i = service->infobar_count() - 1; i >= 0; --i) {
 151       infobars::InfoBar* infobar = service->infobar_at(i);
 152       if (infobar->delegate()->ShouldExpire(
 153               InfoBarService::NavigationDetailsFromLoadCommittedDetails(
 154                   details)))
 155         service->RemoveInfoBar(infobar);
 156     }
 157   }
 158
 159   SupervisedUserService* supervised_user_service =
 160       SupervisedUserServiceFactory::GetForProfile(profile_);
 161   supervised_user_service->AddObserver(this);
 162
 163   interstitial_page_ =
 164       content::InterstitialPage::Create(web_contents_, true, url_, this);
 165   interstitial_page_->Show();
 166
 167   return true;
 168 }
 169
 170 std::string SupervisedUserInterstitial::GetHTMLContents() {
 171   base::DictionaryValue strings;
 172   strings.SetString("blockPageTitle",
 173                     l10n_util::GetStringUTF16(IDS_BLOCK_INTERSTITIAL_TITLE));
 174
 175   SupervisedUserService* supervised_user_service =
 176       SupervisedUserServiceFactory::GetForProfile(profile_);
 177
 178   bool allow_access_requests = supervised_user_service->AccessRequestsEnabled();
 179   strings.SetBoolean("allowAccessRequests", allow_access_requests);
 180
 181   std::string profile_image_url = profile_->GetPrefs()->GetString(
 182       prefs::kSupervisedUserCustodianProfileImageURL);
 183   strings.SetString("avatarURL1x", BuildAvatarImageUrl(profile_image_url,
 184                                                        kAvatarSize1x));
 185   strings.SetString("avatarURL2x", BuildAvatarImageUrl(profile_image_url,
 186                                                        kAvatarSize2x));
 187
 188   std::string profile_image_url2 = profile_->GetPrefs()->GetString(
 189       prefs::kSupervisedUserSecondCustodianProfileImageURL);
 190   strings.SetString("secondAvatarURL1x", BuildAvatarImageUrl(profile_image_url2,
 191                                                              kAvatarSize1x));
 192   strings.SetString("secondAvatarURL2x", BuildAvatarImageUrl(profile_image_url2,
 193                                                              kAvatarSize2x));
 194
 195   base::string16 custodian =
 196       base::UTF8ToUTF16(supervised_user_service->GetCustodianName());
 197   strings.SetString(
 198       "blockPageMessage",
 199       allow_access_requests
 200           ? l10n_util::GetStringFUTF16(IDS_BLOCK_INTERSTITIAL_MESSAGE,
 201                                        custodian)
 202           : l10n_util::GetStringUTF16(
 203                 IDS_BLOCK_INTERSTITIAL_MESSAGE_ACCESS_REQUESTS_DISABLED));
 204
 205   strings.SetString("backButton", l10n_util::GetStringUTF16(IDS_BACK_BUTTON));
 206   strings.SetString(
 207       "requestAccessButton",
 208       l10n_util::GetStringUTF16(IDS_BLOCK_INTERSTITIAL_REQUEST_ACCESS_BUTTON));
 209
 210   strings.SetString(
 211       "requestSentMessage",
 212       l10n_util::GetStringFUTF16(IDS_BLOCK_INTERSTITIAL_REQUEST_SENT_MESSAGE,
 213                                  custodian));
 214
 215   webui::SetFontAndTextDirection(&strings);
 216
 217   base::StringPiece html(ResourceBundle::GetSharedInstance().GetRawDataResource(
 218       IDR_SUPERVISED_USER_BLOCK_INTERSTITIAL_HTML));
 219
 220   return webui::GetI18nTemplateHtml(html, &strings);
 221 }
 222
 223 void SupervisedUserInterstitial::CommandReceived(const std::string& command) {
 224   // For use in histograms.
 225   enum Commands {
 226     PREVIEW,
 227     BACK,
 228     NTP,
 229     ACCESS_REQUEST,
 230     HISTOGRAM_BOUNDING_VALUE
 231   };
 232
 233   if (command == "\"back\"") {
 234     UMA_HISTOGRAM_ENUMERATION("ManagedMode.BlockingInterstitialCommand",
 235                               BACK,
 236                               HISTOGRAM_BOUNDING_VALUE);
 237
 238     // Close the tab if there is no history entry to go back to.
 239     DCHECK(web_contents_->GetController().GetTransientEntry());
 240     if (web_contents_->GetController().GetEntryCount() == 1)
 241       TabCloser::CreateForWebContents(web_contents_);
 242
 243     interstitial_page_->DontProceed();
 244     return;
 245   }
 246
 247   if (command == "\"request\"") {
 248     UMA_HISTOGRAM_ENUMERATION("ManagedMode.BlockingInterstitialCommand",
 249                               ACCESS_REQUEST,
 250                               HISTOGRAM_BOUNDING_VALUE);
 251
 252     SupervisedUserService* supervised_user_service =
 253         SupervisedUserServiceFactory::GetForProfile(profile_);
 254     supervised_user_service->AddAccessRequest(
 255         url_, base::Bind(&SupervisedUserInterstitial::OnAccessRequestAdded,
 256                          weak_ptr_factory_.GetWeakPtr()));
 257     return;
 258   }
 259
 260   NOTREACHED();
 261 }
 262
 263 void SupervisedUserInterstitial::OnProceed() {
 264   // CHECK instead of DCHECK as defense in depth in case we'd accidentally
 265   // proceed on a blocked page.
 266   CHECK(ShouldProceed());
 267   DispatchContinueRequest(true);
 268 }
 269
 270 void SupervisedUserInterstitial::OnDontProceed() {
 271   DispatchContinueRequest(false);
 272 }
 273
 274 void SupervisedUserInterstitial::OnURLFilterChanged() {
 275   if (ShouldProceed())
 276     interstitial_page_->Proceed();
 277 }
 278
 279 void SupervisedUserInterstitial::OnAccessRequestAdded(bool success) {
 280   // TODO(akuegel): Figure out how to show the result of issuing the permission
 281   // request in the UI. Currently, we assume the permission request was created
 282   // successfully.
 283   DVLOG(1) << "Sent access request for " << url_.spec()
 284            << (success ? " successfully" : " unsuccessfully");
 285 }
 286
 287 bool SupervisedUserInterstitial::ShouldProceed() {
 288   SupervisedUserService* supervised_user_service =
 289       SupervisedUserServiceFactory::GetForProfile(profile_);
 290   SupervisedUserURLFilter* url_filter =
 291       supervised_user_service->GetURLFilterForUIThread();
 292   return url_filter->GetFilteringBehaviorForURL(url_) !=
 293          SupervisedUserURLFilter::BLOCK;
 294 }
 295
 296 void SupervisedUserInterstitial::DispatchContinueRequest(
 297     bool continue_request) {
 298   SupervisedUserService* supervised_user_service =
 299       SupervisedUserServiceFactory::GetForProfile(profile_);
 300   supervised_user_service->RemoveObserver(this);
 301
 302   BrowserThread::PostTask(
 303       BrowserThread::IO, FROM_HERE, base::Bind(callback_, continue_request));
 304
 305   // After this, the WebContents may be destroyed. Make sure we don't try to use
 306   // it again.
 307   web_contents_ = NULL;
 308 }