Disable ServiceWorker when JS is disabled

chrome/browser/content_settings/tab_specific_content_settings.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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 88 matching lines @@
               Profile::FromBrowserContext(tab->GetBrowserContext())),
           CONTENT_SETTINGS_TYPE_MIDI_SYSEX),
       pending_protocol_handler_(ProtocolHandler::EmptyProtocolHandler()),
       previous_protocol_handler_(ProtocolHandler::EmptyProtocolHandler()),
       pending_protocol_handler_setting_(CONTENT_SETTING_DEFAULT),
       load_plugins_link_enabled_(true),
       microphone_camera_state_(MICROPHONE_CAMERA_NOT_ACCESSED),
       subresource_filter_enabled_(false),
       subresource_filter_blockage_indicated_(false),
       observer_(this) {
-  ClearBlockedContentSettingsExceptForCookies();
-  ClearCookieSpecificContentSettings();
+  ClearBlockedContentSettingsExceptForNavigationRelatedSettings();
+  ClearNavigationRelatedContentSettings();
 
   observer_.Add(HostContentSettingsMapFactory::GetForProfile(
       Profile::FromBrowserContext(tab->GetBrowserContext())));
 }
 
 TabSpecificContentSettings::~TabSpecificContentSettings() {
   FOR_EACH_OBSERVER(
       SiteDataObserver, observer_list_, ContentSettingsDestroyed());
 }
 
@@ skipping 89 matching lines @@
                                                     const GURL& url,
                                                     bool blocked_by_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabSpecificContentSettings* settings = GetForFrame(
       render_process_id, render_frame_id);
   if (settings)
     settings->OnFileSystemAccessed(url, blocked_by_policy);
 }
 
 // static
-void TabSpecificContentSettings::ServiceWorkerAccessed(int render_process_id,
-                                                       int render_frame_id,
-                                                       const GURL& scope,
-                                                       bool blocked_by_policy) {
+void TabSpecificContentSettings::ServiceWorkerAccessed(
+    int render_process_id,
+    int render_frame_id,
+    const GURL& scope,
+    bool blocked_by_policy_javascript,
+    bool blocked_by_policy_cookie) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabSpecificContentSettings* settings =
       GetForFrame(render_process_id, render_frame_id);
   if (settings)
-    settings->OnServiceWorkerAccessed(scope, blocked_by_policy);
+    settings->OnServiceWorkerAccessed(scope, blocked_by_policy_javascript,
+                                      blocked_by_policy_cookie);
 }
 
 bool TabSpecificContentSettings::IsContentBlocked(
     ContentSettingsType content_type) const {
   DCHECK_NE(CONTENT_SETTINGS_TYPE_GEOLOCATION, content_type)
       << "Geolocation settings handled by ContentSettingGeolocationImageModel";
   DCHECK_NE(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, content_type)
       << "Notifications settings handled by "
       << "ContentSettingsNotificationsImageModel";
 
@@ skipping 224 matching lines @@
   if (blocked_by_policy)
     OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   else
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnServiceWorkerAccessed(
     const GURL& scope,
-    bool blocked_by_policy) {
+    bool blocked_by_policy_javascript,
+    bool blocked_by_policy_cookie) {
   DCHECK(scope.is_valid());
-  if (blocked_by_policy) {
+  if (blocked_by_policy_javascript || blocked_by_policy_cookie) {
     blocked_local_shared_objects_.service_workers()->AddServiceWorker(
         scope.GetOrigin(), std::vector<GURL>(1, scope));
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.service_workers()->AddServiceWorker(
         scope.GetOrigin(), std::vector<GURL>(1, scope));
+  }
+
+  if (blocked_by_policy_javascript) {
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
+  } else {
+    OnContentAllowed(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
+  }
+  if (blocked_by_policy_cookie) {
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
+  } else {
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnWebDatabaseAccessed(
     const GURL& url,
     const base::string16& name,
     const base::string16& display_name,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
@@ skipping 152 matching lines @@
   midi_usages_state_.OnPermissionSet(requesting_origin, true);
   OnContentAllowed(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
 void TabSpecificContentSettings::OnMidiSysExAccessBlocked(
     const GURL& requesting_origin) {
   midi_usages_state_.OnPermissionSet(requesting_origin, false);
   OnContentBlocked(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
-void TabSpecificContentSettings::ClearBlockedContentSettingsExceptForCookies() {
+void TabSpecificContentSettings::
+ClearBlockedContentSettingsExceptForNavigationRelatedSettings() {
   for (auto& status : content_settings_status_) {
-    if (status.first == CONTENT_SETTINGS_TYPE_COOKIES)
+    if (status.first == CONTENT_SETTINGS_TYPE_COOKIES ||
+        status.first == CONTENT_SETTINGS_TYPE_JAVASCRIPT)

[falken, 2016/10/05 01:16:50]

Why was this change needed? Before this patch, if you block JS on a site, the
icon would be cleared immediately?

[shimazu, 2016/10/05 02:10:57]

Yes, the icon will be shown during navigation and be cleared after navigation
without this change.
I heard from jochen that previously the setting of cookies is only needed for
navigation, so I added that because now the service workers additionally
requires the JS settings. I'm still not sure why the other settings should be
cleared after the navigation though.. I'm guessing it's a kind of white listing,
but no confidence.

       continue;
     status.second.blocked = false;
     status.second.blockage_indicated_to_user = false;
     status.second.allowed = false;
   }
   microphone_camera_state_ = MICROPHONE_CAMERA_NOT_ACCESSED;
   load_plugins_link_enabled_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
       content::Source<WebContents>(web_contents()),
       content::NotificationService::NoDetails());
 }
 
-void TabSpecificContentSettings::ClearCookieSpecificContentSettings() {
+void TabSpecificContentSettings::ClearNavigationRelatedContentSettings() {
   blocked_local_shared_objects_.Reset();
   allowed_local_shared_objects_.Reset();
-  ContentSettingsStatus& status =
-      content_settings_status_[CONTENT_SETTINGS_TYPE_COOKIES];
-  status.blocked = false;
-  status.blockage_indicated_to_user = false;
-  status.allowed = false;
+  for (ContentSettingsType type :
+    {CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTINGS_TYPE_JAVASCRIPT}) {
+    ContentSettingsStatus& status =
+        content_settings_status_[type];
+    status.blocked = false;
+    status.blockage_indicated_to_user = false;
+    status.allowed = false;
+  }
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
       content::Source<WebContents>(web_contents()),
       content::NotificationService::NoDetails());
 }
 
 void TabSpecificContentSettings::SetDownloadsBlocked(bool blocked) {
   ContentSettingsStatus& status =
       content_settings_status_[CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS];
   status.blocked = blocked;
@@ skipping 96 matching lines @@
       web_contents()->GetController();
   content::NavigationEntry* last_committed_entry =
       controller.GetLastCommittedEntry();
   if (last_committed_entry)
     previous_url_ = last_committed_entry->GetURL();
 
   // If we're displaying a network error page do not reset the content
   // settings delegate's cookies so the user has a chance to modify cookie
   // settings.
   if (!navigation_handle->IsErrorPage())
-    ClearCookieSpecificContentSettings();
+    ClearNavigationRelatedContentSettings();
   ClearGeolocationContentSettings();
   ClearMidiContentSettings();
   ClearPendingProtocolHandler();
 }
 
 void TabSpecificContentSettings::DidFinishNavigation(
       content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame() ||
       !navigation_handle->HasCommitted() ||
       navigation_handle->IsSamePage()) {
     return;
   }
 
   // Clear "blocked" flags.
-  ClearBlockedContentSettingsExceptForCookies();
+  ClearBlockedContentSettingsExceptForNavigationRelatedSettings();
   blocked_plugin_names_.clear();
   GeolocationDidNavigate(navigation_handle);
   MidiDidNavigate(navigation_handle);
 
   if (web_contents()->GetVisibleURL().SchemeIsHTTPOrHTTPS()) {
     content_settings::RecordPluginsAction(
         content_settings::PLUGINS_ACTION_TOTAL_NAVIGATIONS);
   }
 }
 
@@ skipping 66 matching lines @@
       static_cast<MicrophoneCameraStateFlags>(
           TabSpecificContentSettings::MICROPHONE_ACCESSED |
           TabSpecificContentSettings::MICROPHONE_BLOCKED |
           TabSpecificContentSettings::CAMERA_ACCESSED |
           TabSpecificContentSettings::CAMERA_BLOCKED);
   OnMediaStreamPermissionSet(
       web_contents()->GetLastCommittedURL(),
       media_blocked,
       std::string(), std::string(), std::string(), std::string());
 }