[subresource_filter] Decide UNSUPPORTED_SCHEME only if we'd otherwise activate

components/subresource_filter/content/browser/content_subresource_filter_driver_factory.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 "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
@@ skipping 110 matching lines @@
   DCHECK_NE(activation_options_.activation_level, ActivationLevel::DISABLED);
   ActivationState state = ActivationState(activation_options_.activation_level);
   state.measure_performance = ShouldMeasurePerformanceForPageLoad(
       activation_options_.performance_measurement_rate);
   // TODO(csharrison): Set state.enable_logging based on metadata returns from
   // the safe browsing filter, when it is available. Add tests for this
   // behavior.
   throttle_manager_->NotifyPageActivationComputed(navigation_handle, state);
 }
 
+// Be careful when modifying this method, as the order in which the
+// activation_decision_ is decided is very important and corresponds to UMA
+// metrics. In general we want to follow the pattern that
+// ACTIVATION_CONDITIONS_NOT_MET will always be logged if no configuration
+// matches this navigation. We log other decisions only if a configuration
+// matches and also would have activated.
 void ContentSubresourceFilterDriverFactory::
     ComputeActivationForMainFrameNavigation(
         content::NavigationHandle* navigation_handle,
         ActivationList matched_list) {
   const GURL& url(navigation_handle->GetURL());
 
-  if (!url.SchemeIsHTTPOrHTTPS()) {
-    activation_decision_ = ActivationDecision::UNSUPPORTED_SCHEME;
-    activation_options_ = Configuration::ActivationOptions();
-    return;
-  }
-
+  bool scheme_is_http_or_https = url.SchemeIsHTTPOrHTTPS();
   const auto config_list = GetEnabledConfigurations();
   const auto highest_priority_activated_config =
       std::find_if(config_list->configs_by_decreasing_priority().begin(),
                    config_list->configs_by_decreasing_priority().end(),
-                   [&url, matched_list, this](const Configuration& config) {
+                   [&url, scheme_is_http_or_https, matched_list,
+                    this](const Configuration& config) {
                      return DoesMainFrameURLSatisfyActivationConditions(
-                         url, config.activation_conditions, matched_list);
+                         url, scheme_is_http_or_https,
+                         config.activation_conditions, matched_list);
                    });
 
   bool has_activated_config =
       highest_priority_activated_config !=
       config_list->configs_by_decreasing_priority().end();
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("loading"),
                "ContentSubresourceFilterDriverFactory::"
                "ComputeActivationForMainFrameNavigation",
                "highest_priority_activated_config",
                has_activated_config
                    ? highest_priority_activated_config->ToTracedValue()
                    : base::MakeUnique<base::trace_event::TracedValue>());
   if (!has_activated_config) {
     activation_decision_ = ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET;
     activation_options_ = Configuration::ActivationOptions();
     return;
   }
 
-  activation_options_ = highest_priority_activated_config->activation_options;
+  const Configuration::ActivationOptions& activation_options =
+      highest_priority_activated_config->activation_options;
+
+  // Log UNSUPPORTED_SCHEME if we would have otherwise activated.
+  if (!scheme_is_http_or_https &&
+      activation_options.activation_level != ActivationLevel::DISABLED) {
+    activation_decision_ = ActivationDecision::UNSUPPORTED_SCHEME;
+    activation_options_ = Configuration::ActivationOptions();
+    return;
+  }
+
+  activation_options_ = activation_options;
   activation_decision_ =
       activation_options_.activation_level == ActivationLevel::DISABLED
           ? ActivationDecision::ACTIVATION_DISABLED
           : ActivationDecision::ACTIVATED;
 }
 
 bool ContentSubresourceFilterDriverFactory::
     DoesMainFrameURLSatisfyActivationConditions(
         const GURL& url,
+        bool scheme_is_http_or_https,
         const Configuration::ActivationConditions& conditions,
         ActivationList matched_list) const {
+  // scheme_is_http_or_https implies url.SchemeIsHTTPOrHTTPS().
+  DCHECK(!scheme_is_http_or_https || url.SchemeIsHTTPOrHTTPS());
   switch (conditions.activation_scope) {
     case ActivationScope::ALL_SITES:
       return true;
     case ActivationScope::ACTIVATION_LIST:
+      // ACTIVATION_LIST does not support non http/s URLs.
+      if (!scheme_is_http_or_https)
+        return false;
       if (conditions.activation_list == matched_list)
         return true;
       if (conditions.activation_list == ActivationList::PHISHING_INTERSTITIAL &&
           matched_list == ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL) {
         // Handling special case, where activation on the phishing sites also
         // mean the activation on the sites with social engineering metadata.
         return true;
       }
       return false;
     case ActivationScope::NO_SITES:
@@ skipping 40 matching lines @@
   if (navigation_handle->IsInMainFrame() &&
       !navigation_handle->IsSameDocument() &&
       activation_decision_ == ActivationDecision::UNKNOWN &&
       navigation_handle->HasCommitted()) {
     activation_decision_ = ActivationDecision::ACTIVATION_DISABLED;
     activation_options_ = Configuration::ActivationOptions();
   }
 }
 
 }  // namespace subresource_filter