[sensors] Add Permission guard to the generic sensor apis.

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 80 matching lines @@
       blocked_local_shared_objects_(
           Profile::FromBrowserContext(tab->GetBrowserContext())),
       geolocation_usages_state_(
           HostContentSettingsMapFactory::GetForProfile(
               Profile::FromBrowserContext(tab->GetBrowserContext())),
           CONTENT_SETTINGS_TYPE_GEOLOCATION),
       midi_usages_state_(
           HostContentSettingsMapFactory::GetForProfile(
               Profile::FromBrowserContext(tab->GetBrowserContext())),
           CONTENT_SETTINGS_TYPE_MIDI_SYSEX),
+      // TODO(riju): when UMA is ready
+      /*
+      sensors_usages_state_(
+          HostContentSettingsMapFactory::GetForProfile(
+              Profile::FromBrowserContext(tab->GetBrowserContext())),
+          CONTENT_SETTINGS_TYPE_SENSORS),
+      */
       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) {
   ClearContentSettingsExceptForNavigationRelatedSettings();
   ClearNavigationRelatedContentSettings();
@@ skipping 132 matching lines @@
       content_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
       content_type == CONTENT_SETTINGS_TYPE_PLUGINS ||
       content_type == CONTENT_SETTINGS_TYPE_COOKIES ||
       content_type == CONTENT_SETTINGS_TYPE_POPUPS ||
       content_type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT ||
       content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
       content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA ||
       content_type == CONTENT_SETTINGS_TYPE_PPAPI_BROKER ||
       content_type == CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS ||
       content_type == CONTENT_SETTINGS_TYPE_MIDI_SYSEX ||
+      // content_type == CONTENT_SETTINGS_TYPE_SENSORS ||
       content_type == CONTENT_SETTINGS_TYPE_KEYGEN) {
     const auto& it = content_settings_status_.find(content_type);
     if (it != content_settings_status_.end())
       return it->second.blocked;
   }
 
   return false;
 }
 
 bool TabSpecificContentSettings::IsSubresourceBlocked() const {
@@ skipping 23 matching lines @@
 
 bool TabSpecificContentSettings::IsContentAllowed(
     ContentSettingsType content_type) const {
   // This method currently only returns meaningful values for the content type
   // cookies, media, PPAPI broker, downloads, and MIDI sysex.
   if (content_type != CONTENT_SETTINGS_TYPE_COOKIES &&
       content_type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
       content_type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA &&
       content_type != CONTENT_SETTINGS_TYPE_PPAPI_BROKER &&
       content_type != CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS &&
+      // content_type != CONTENT_SETTINGS_TYPE_SENSORS &&
       content_type != CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
     return false;
   }
 
   const auto& it = content_settings_status_.find(content_type);
   if (it != content_settings_status_.end())
     return it->second.allowed;
   return false;
 }
 
@@ skipping 351 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::OnSensorAccessed(
+    const GURL& requesting_origin) {
+  OnContentAllowed(CONTENT_SETTINGS_TYPE_SENSORS);
+}
+
+void TabSpecificContentSettings::OnSensorAccessBlocked(
+    const GURL& requesting_origin) {
+  OnContentBlocked(CONTENT_SETTINGS_TYPE_SENSORS);
+}
+
 void TabSpecificContentSettings::
 ClearContentSettingsExceptForNavigationRelatedSettings() {
   for (auto& status : content_settings_status_) {
     if (status.first == CONTENT_SETTINGS_TYPE_COOKIES ||
         status.first == CONTENT_SETTINGS_TYPE_JAVASCRIPT)
       continue;
     status.second.blocked = false;
     status.second.blockage_indicated_to_user = false;
     status.second.allowed = false;
   }
@@ skipping 133 matching lines @@
   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())
     ClearNavigationRelatedContentSettings();
   ClearGeolocationContentSettings();
   ClearMidiContentSettings();
+  // ClearSensorContentSettings();
   ClearPendingProtocolHandler();
 }
 
 void TabSpecificContentSettings::DidFinishNavigation(
       content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame() ||
       !navigation_handle->HasCommitted() ||
       navigation_handle->IsSamePage()) {
     return;
   }
 
   // Clear "blocked" flags.
   ClearContentSettingsExceptForNavigationRelatedSettings();
   blocked_plugin_names_.clear();
   GeolocationDidNavigate(navigation_handle);
   MidiDidNavigate(navigation_handle);
+  // SensorDidNavigate(navigation_handle);
 
   if (web_contents()->GetVisibleURL().SchemeIsHTTPOrHTTPS()) {
     content_settings::RecordPluginsAction(
         content_settings::PLUGINS_ACTION_TOTAL_NAVIGATIONS);
   }
 }
 
 void TabSpecificContentSettings::AppCacheAccessed(const GURL& manifest_url,
                                                   bool blocked_by_policy) {
   if (blocked_by_policy) {
@@ skipping 21 matching lines @@
 }
 
 void TabSpecificContentSettings::ClearGeolocationContentSettings() {
   geolocation_usages_state_.ClearStateMap();
 }
 
 void TabSpecificContentSettings::ClearMidiContentSettings() {
   midi_usages_state_.ClearStateMap();
 }
 
+/*
+void TabSpecificContentSettings::ClearSensorContentSettings() {
+  sensors_usages_state_.ClearStateMap();
+}
+*/
+
 void TabSpecificContentSettings::GeolocationDidNavigate(
     content::NavigationHandle* navigation_handle) {
   ContentSettingsUsagesState::CommittedDetails committed_details;
   committed_details.current_url = navigation_handle->GetURL();
   committed_details.previous_url = previous_url_;
 
   geolocation_usages_state_.DidNavigate(committed_details);
 }
 
 void TabSpecificContentSettings::MidiDidNavigate(
     content::NavigationHandle* navigation_handle) {
   ContentSettingsUsagesState::CommittedDetails committed_details;
   committed_details.current_url = navigation_handle->GetURL();
   committed_details.previous_url = previous_url_;
   midi_usages_state_.DidNavigate(committed_details);
 }
 
+/*
+void TabSpecificContentSettings::SensorDidNavigate(
+    content::NavigationHandle* navigation_handle) {
+  ContentSettingsUsagesState::CommittedDetails committed_details;
+  committed_details.current_url = navigation_handle->GetURL();
+  committed_details.previous_url = previous_url_;
+  sensors_usages_state_.DidNavigate(committed_details);
+}
+*/
+
 void TabSpecificContentSettings::BlockAllContentForTesting() {
   content_settings::ContentSettingsRegistry* registry =
       content_settings::ContentSettingsRegistry::GetInstance();
   for (const content_settings::ContentSettingsInfo* info : *registry) {
     ContentSettingsType type = info->website_settings_info()->type();
     if (type != CONTENT_SETTINGS_TYPE_GEOLOCATION &&
         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
       OnContentBlocked(type);
     }
   }
 
   // Geolocation and media must be blocked separately, as the generic
   // TabSpecificContentSettings::OnContentBlocked does not apply to them.
   OnGeolocationPermissionSet(web_contents()->GetLastCommittedURL(), false);
   MicrophoneCameraStateFlags media_blocked =
       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());
 }