Site Settings Desktop: Support adding exceptions for incognito mode.

chrome/browser/ui/webui/settings/site_settings_handler.cc

 // Copyright 2016 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/ui/webui/settings/site_settings_handler.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/site_settings_helper.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/common/quota/quota_status_code.h"
 #include "ui/base/text/bytes_formatting.h"
 
-
 namespace settings {
 
 namespace {
 
 const char kAppName[] = "appName";
 const char kAppId[] = "appId";
 
 // Return an appropriate API Permission ID for the given string name.
 extensions::APIPermission::APIPermission::ID APIPermissionFromGroupName(
     std::string type) {
@@ skipping 104 matching lines @@
       base::Bind(&SiteSettingsHandler::HandleResetCategoryPermissionForOrigin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setCategoryPermissionForOrigin",
       base::Bind(&SiteSettingsHandler::HandleSetCategoryPermissionForOrigin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "isPatternValid",
       base::Bind(&SiteSettingsHandler::HandleIsPatternValid,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "updateIncognitoStatus",
+      base::Bind(&SiteSettingsHandler::HandleUpdateIncognitoStatus,
+                 base::Unretained(this)));
 }
 
 void SiteSettingsHandler::OnJavascriptAllowed() {
   observer_.Add(HostContentSettingsMapFactory::GetForProfile(profile_));
   if (profile_->HasOffTheRecordProfile()) {
     auto* map = HostContentSettingsMapFactory::GetForProfile(
         profile_->GetOffTheRecordProfile());
     if (!observer_.IsObserving(map))
       observer_.Add(map);
   }
+
+  notification_registrar_.Add(
+      this, chrome::NOTIFICATION_PROFILE_CREATED,
+      content::NotificationService::AllSources());
+  notification_registrar_.Add(
+      this, chrome::NOTIFICATION_PROFILE_DESTROYED,
+      content::NotificationService::AllSources());
 }
 
 void SiteSettingsHandler::OnJavascriptDisallowed() {
   observer_.RemoveAll();

[dschuyler, 2016/08/31 21:48:52]

Should we do something with notification_registrar_
here? Maybe
notification_registrar_.RemoveAll();

(Try doing a page refresh on the page using
this handler, if that crashes or 
triggers a DCHECK, then clearing the 
notification_registrar_ may clear that up).

[Finnur, 2016/09/01 11:10:15]

NotificationRegistrar calls RemoveAll in the dtor, so we should be good.
I looked up a few samples on code search and the first five I found did not
clean up explicitly.

[dschuyler, 2016/09/01 23:13:49]

Ah, please look specifically within 
chrome/browser/ui/webui/settings.

[Finnur, 2016/09/02 15:44:14]

Acknowledged.

 }
 
 void SiteSettingsHandler::OnGetUsageInfo(
     const storage::UsageInfoEntries& entries) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   for (const auto& entry : entries) {
     if (entry.usage <= 0) continue;
     if (entry.host == usage_host_) {
       CallJavascriptFunction("settings.WebsiteUsagePrivateApi.returnUsageTotal",
@@ skipping 32 matching lines @@
         base::StringValue("contentSettingSitePermissionChanged"),
         base::StringValue(site_settings::ContentSettingsTypeToGroupName(
             content_type)),
         base::StringValue(primary_pattern.ToString()),
         base::StringValue(
             secondary_pattern == ContentSettingsPattern::Wildcard() ?
             "" : secondary_pattern.ToString()));
   }
 }
 
+void SiteSettingsHandler::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_PROFILE_DESTROYED: {
+      Profile* profile = content::Source<Profile>(source).ptr();

[dschuyler, 2016/08/31 21:48:52]

Just a question (feel free to ignore):

Will we get profiles other than this.profile_?
i.e. will this profile be the same as profile_?

or will it sometimes be profile_->GetOffTheRecordProfile()
or something else?

[Finnur, 2016/09/01 11:10:15]

No, it is an excellent question.
Yes, we can get a pointer to any random profile that is created/destroyed,
incognito or not. And we don't want to handle all of them. Addressed.

+      SendIncognitoStatus(true, profile);
+
+      HostContentSettingsMap* settings_map =
+          HostContentSettingsMapFactory::GetForProfile(profile);
+      if (profile->IsOffTheRecord() &&
+          observer_.IsObserving(settings_map)) {
+        observer_.Remove(settings_map);
+      }
+
+      break;
+    }
+
+    case chrome::NOTIFICATION_PROFILE_CREATED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      SendIncognitoStatus(false, profile);
+
+      observer_.Add(HostContentSettingsMapFactory::GetForProfile(profile));
+      break;
+    }
+  }
+}
+
 void SiteSettingsHandler::HandleFetchUsageTotal(
     const base::ListValue* args) {
   AllowJavascript();
 
   CHECK_EQ(1U, args->GetSize());
   std::string host;
   CHECK(args->GetString(0, &host));
   usage_host_ = host;
 
   scoped_refptr<StorageInfoFetcher> storage_info_fetcher
@@ skipping 114 matching lines @@
 
   CHECK_EQ(2U, args->GetSize());
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
   std::string type;
   CHECK(args->GetString(1, &type));
   ContentSettingsType content_type =
       static_cast<ContentSettingsType>(static_cast<int>(
           site_settings::ContentSettingsTypeFromGroupName(type)));
 
+  std::unique_ptr<base::ListValue> exceptions(new base::ListValue);
+
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
-  std::unique_ptr<base::ListValue> exceptions(new base::ListValue);
-
   AddExceptionsGrantedByHostedApps(profile_, APIPermissionFromGroupName(type),
       exceptions.get());
+  site_settings::GetExceptionsFromHostContentSettingsMap(
+      map, content_type, web_ui(), false, exceptions.get());
 
-  site_settings::GetExceptionsFromHostContentSettingsMap(
-      map, content_type, web_ui(), exceptions.get());
+  if (profile_->HasOffTheRecordProfile()) {
+    Profile* incognito = profile_->GetOffTheRecordProfile();
+    map = HostContentSettingsMapFactory::GetForProfile(incognito);
+    site_settings::GetExceptionsFromHostContentSettingsMap(
+        map, content_type, web_ui(), true, exceptions.get());
+  }
+
   ResolveJavascriptCallback(*callback_id, *exceptions.get());
 }
 
 void SiteSettingsHandler::HandleResetCategoryPermissionForOrigin(
     const base::ListValue* args) {
-  CHECK_EQ(3U, args->GetSize());
+  CHECK_EQ(4U, args->GetSize());
   std::string primary_pattern;
   CHECK(args->GetString(0, &primary_pattern));
   std::string secondary_pattern;
   CHECK(args->GetString(1, &secondary_pattern));
   std::string type;
   CHECK(args->GetString(2, &type));
+  bool incognito;
+  CHECK(args->GetBoolean(3, &incognito));
 
   ContentSettingsType content_type =
       static_cast<ContentSettingsType>(static_cast<int>(
           site_settings::ContentSettingsTypeFromGroupName(type)));
 
+  Profile* profile = incognito ?
+      (profile_->HasOffTheRecordProfile()
+          ? profile_->GetOffTheRecordProfile() : nullptr) : profile_;

[dschuyler, 2016/08/31 21:48:52]

Optional: I'm found this hard to parse and I'm 
wondering if a different layout would help. WDYT 
of:

Profile* profile = incognito 
    ? (profile_->HasOffTheRecordProfile()
        ? profile_->GetOffTheRecordProfile() 
        : nullptr) 
    : profile_;

or

Profile* profile = 
    incognito ? 
        (profile_->HasOffTheRecordProfile() ?
            profile_->GetOffTheRecordProfile() :
            nullptr) :
        profile_;

[Finnur, 2016/09/01 11:10:15]

Done.

+  if (!profile)
+    return;
+
   HostContentSettingsMap* map =
-      HostContentSettingsMapFactory::GetForProfile(profile_);
+      HostContentSettingsMapFactory::GetForProfile(profile);
   map->SetContentSettingCustomScope(
       ContentSettingsPattern::FromString(primary_pattern),
       secondary_pattern.empty() ?
           ContentSettingsPattern::Wildcard() :
           ContentSettingsPattern::FromString(secondary_pattern),
       content_type, "", CONTENT_SETTING_DEFAULT);
 }
 
 void SiteSettingsHandler::HandleSetCategoryPermissionForOrigin(
     const base::ListValue* args) {
-  CHECK_EQ(4U, args->GetSize());
+  CHECK_EQ(5U, args->GetSize());
   std::string primary_pattern;
   CHECK(args->GetString(0, &primary_pattern));
   std::string secondary_pattern;
   CHECK(args->GetString(1, &secondary_pattern));
   std::string type;
   CHECK(args->GetString(2, &type));
   std::string value;
   CHECK(args->GetString(3, &value));
+  bool incognito;
+  CHECK(args->GetBoolean(4, &incognito));
 
   ContentSettingsType content_type =
       static_cast<ContentSettingsType>(static_cast<int>(
           site_settings::ContentSettingsTypeFromGroupName(type)));
   ContentSetting setting;
   CHECK(content_settings::ContentSettingFromString(value, &setting));
 
+  Profile* profile = incognito ?
+      (profile_->HasOffTheRecordProfile()
+          ? profile_->GetOffTheRecordProfile() : nullptr) : profile_;

[dschuyler, 2016/08/31 21:48:52]

If you decide to change the layout of the
ternary above, this could be formatted in 
a similar way.

[Finnur, 2016/09/01 11:10:15]

Done.

+  if (!profile)
+    return;
+
   HostContentSettingsMap* map =
-      HostContentSettingsMapFactory::GetForProfile(profile_);
+      HostContentSettingsMapFactory::GetForProfile(profile);
   map->SetContentSettingCustomScope(
       ContentSettingsPattern::FromString(primary_pattern),
       secondary_pattern.empty() ?
           ContentSettingsPattern::Wildcard() :
           ContentSettingsPattern::FromString(secondary_pattern),
       content_type, "", setting);
 }
 
 void SiteSettingsHandler::HandleIsPatternValid(
     const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
   std::string pattern_string;
   CHECK(args->GetString(1, &pattern_string));
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString(pattern_string);
   ResolveJavascriptCallback(
       *callback_id, base::FundamentalValue(pattern.IsValid()));
 }
 
+void SiteSettingsHandler::HandleUpdateIncognitoStatus(
+    const base::ListValue* args) {
+  AllowJavascript();
+  SendIncognitoStatus(false, profile_);
+}
+
+bool SiteSettingsHandler::IsOurIncognitoProfile(Profile* profile) {
+  return profile_->HasOffTheRecordProfile() &&
+      profile == profile_->GetOffTheRecordProfile();
+}
+
+void SiteSettingsHandler::SendIncognitoStatus(bool destroy, Profile* profile) {
+  if (!IsJavascriptAllowed())
+    return;
+
+  // When an incognito profile is destroyed, it sends out the destruction
+  // message before destroying, so HasOffTheRecordProfile for profile_ won't
+  // return false until after the profile actually been destroyed.

[dschuyler, 2016/08/31 21:48:52]

Thanks for that comment!

[Finnur, 2016/09/01 11:10:15]

No problem. :)

+  bool incognito_enabled = profile_->HasOffTheRecordProfile();
+  if (incognito_enabled && destroy &&
+      profile == profile_->GetOffTheRecordProfile()) {
+    incognito_enabled = false;  // Our incognito profile was just destroyed.
+  }
+
+  if (profile == profile_ || IsOurIncognitoProfile(profile)) {
+    CallJavascriptFunction("cr.webUIListenerCallback",
+                           base::StringValue("onIncognitoStatusChanged"),
+                           base::FundamentalValue(incognito_enabled));
+  }
+}
+
 }  // namespace settings