Introduce session type parameter to extension features

chrome/common/extensions/api/common_extension_api_unittest.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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/features/api_feature.h"
+#include "extensions/common/features/feature_session_type.h"
 #include "extensions/common/features/json_feature_provider.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 using test_util::BuildExtension;
 
+namespace {
+
+struct FeatureSessionTypesTestData {
+  std::string api_name;
+  bool expect_available;
+  FeatureSessionType current_session_type;
+};
+
 SimpleFeature* CreateAPIFeature() {
   return new APIFeature();
 }
 
+std::unique_ptr<base::DictionaryValue> GetJSONFeatures() {
+  base::FilePath api_features_path;
+  PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
+  api_features_path = api_features_path.AppendASCII("extensions")
+                          .AppendASCII("extension_api_unittest")
+                          .AppendASCII("api_features.json");
+
+  std::string api_features_str;
+  if (!base::ReadFileToString(api_features_path, &api_features_str)) {
+    ADD_FAILURE() << "api_features.json unreadable";
+    return std::unique_ptr<base::DictionaryValue>();
+  }
+
+  return std::unique_ptr<base::DictionaryValue>(
+      static_cast<base::DictionaryValue*>(
+          base::JSONReader::Read(api_features_str).release()));
+}
+
+void RegisterAPISchemaResourcesForTest(ExtensionAPI* api,
+                                       const base::DictionaryValue& features) {
+  for (base::DictionaryValue::Iterator iter(features); !iter.IsAtEnd();
+       iter.Advance()) {
+    if (iter.key().find(".") == std::string::npos)
+      api->RegisterSchemaResource(iter.key(), 0);
+  }
+}
+
+}  // namespace
+
 TEST(ExtensionAPITest, Creation) {
   ExtensionAPI* shared_instance = ExtensionAPI::GetSharedInstance();
   EXPECT_EQ(shared_instance, ExtensionAPI::GetSharedInstance());
 
   std::unique_ptr<ExtensionAPI> new_instance(
       ExtensionAPI::CreateWithDefaultConfiguration());
   EXPECT_NE(new_instance.get(),
             std::unique_ptr<ExtensionAPI>(
                 ExtensionAPI::CreateWithDefaultConfiguration())
                 .get());
@@ skipping 104 matching lines @@
     { "parent3.noparent", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
     { "parent3.noparent", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
     { "parent3.noparent", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
     { "parent3.noparent.child", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
     { "parent3.noparent.child", true, Feature::BLESSED_EXTENSION_CONTEXT,
         GURL() },
     { "parent3.noparent.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT,
         GURL() }
   };
 
-  base::FilePath api_features_path;
-  PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
-  api_features_path = api_features_path.AppendASCII("extensions")
-      .AppendASCII("extension_api_unittest")
-      .AppendASCII("api_features.json");
-
-  std::string api_features_str;
-  ASSERT_TRUE(base::ReadFileToString(
-      api_features_path, &api_features_str)) << "api_features.json";
-
-  std::unique_ptr<base::DictionaryValue> value(
-      static_cast<base::DictionaryValue*>(
-          base::JSONReader::Read(api_features_str).release()));
+  std::unique_ptr<base::DictionaryValue> value(GetJSONFeatures());
+  ASSERT_TRUE(value);
   JSONFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
-    for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
-         iter.Advance()) {
-      if (iter.key().find(".") == std::string::npos)
-        api.RegisterSchemaResource(iter.key(), 0);
-    }
+    RegisterAPISchemaResourcesForTest(&api, *value);
+    ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
-    ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
     bool expected = test_data[i].expect_is_available;
     Feature::Availability availability =
         api.IsAvailable(test_data[i].api_full_name,
                         NULL,
                         test_data[i].context,
                         test_data[i].url);
     EXPECT_EQ(expected, availability.is_available())
         << base::StringPrintf("Test %d: Feature '%s' was %s: %s",
                               static_cast<int>(i),
                               test_data[i].api_full_name.c_str(),
@@ skipping 49 matching lines @@
         GURL("http://google.com") },
     { "test3", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
     { "test3", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
     { "test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL,
         GURL("http://google.com") },
     { "test7", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://bar.com") }
   };
 
-  base::FilePath api_features_path;
-  PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
-  api_features_path = api_features_path.AppendASCII("extensions")
-      .AppendASCII("extension_api_unittest")
-      .AppendASCII("api_features.json");
-
-  std::string api_features_str;
-  ASSERT_TRUE(base::ReadFileToString(
-      api_features_path, &api_features_str)) << "api_features.json";
-
-  std::unique_ptr<base::DictionaryValue> value(
-      static_cast<base::DictionaryValue*>(
-          base::JSONReader::Read(api_features_str).release()));
+  std::unique_ptr<base::DictionaryValue> value(GetJSONFeatures());
+  ASSERT_TRUE(value);
   JSONFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
-    for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
-         iter.Advance()) {
-      if (iter.key().find(".") == std::string::npos)
-        api.RegisterSchemaResource(iter.key(), 0);
-    }
+    RegisterAPISchemaResourcesForTest(&api, *value);
+    ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     Feature* test_feature =
         api_feature_provider.GetFeature(test_data[i].api_full_name);
     ASSERT_TRUE(test_feature);
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAnyFeatureAvailableToContext(*test_feature,
                                                  test_data[i].extension,
                                                  test_data[i].context,
                                                  test_data[i].url))
         << i;
   }
 }
 
+TEST(ExtensionAPITest, SessionTypeFeature) {
+  const std::vector<FeatureSessionTypesTestData> kTestData(
+      {{"kiosk_only", true, FeatureSessionType::KIOSK},
+       {"kiosk_only", false, FeatureSessionType::REGULAR},
+       {"kiosk_only", false, FeatureSessionType::UNKNOWN},
+       {"non_kiosk", false, FeatureSessionType::KIOSK},
+       {"non_kiosk", true, FeatureSessionType::REGULAR},
+       {"non_kiosk", false, FeatureSessionType::UNKNOWN},
+       {"all_session_types", true, FeatureSessionType::KIOSK},
+       {"all_session_types", true, FeatureSessionType::REGULAR},
+       {"all_session_types", false, FeatureSessionType::UNKNOWN},
+       {"empty_session_types", false, FeatureSessionType::KIOSK},
+       {"empty_session_types", false, FeatureSessionType::REGULAR},
+       {"empty_session_types", false, FeatureSessionType::UNKNOWN},
+       {"invalid_session_types", false, FeatureSessionType::KIOSK},

[Devlin, 2016/08/23 20:49:06]

Does this feature exist?

[tbarzic, 2016/09/08 18:48:54]

no, removed

+       {"invalid_session_types", false, FeatureSessionType::REGULAR},
+       {"invalid_session_types", false, FeatureSessionType::UNKNOWN},
+       {"test1", true, FeatureSessionType::KIOSK},
+       {"test1", true, FeatureSessionType::REGULAR},
+       {"test1", true, FeatureSessionType::UNKNOWN}});
+
+  std::unique_ptr<base::DictionaryValue> value(GetJSONFeatures());
+  ASSERT_TRUE(value);
+  JSONFeatureProvider api_feature_provider(*value, CreateAPIFeature);
+
+  for (const auto& test : kTestData) {
+    ExtensionAPI api;
+    api.RegisterDependencyProvider("api", &api_feature_provider);
+    RegisterAPISchemaResourcesForTest(&api, *value);
+    ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
+
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> current_session(
+        ScopedCurrentFeatureSessionType(test.current_session_type));
+    EXPECT_EQ(test.expect_available,
+              api.IsAvailable(test.api_name, NULL,
+                              Feature::BLESSED_EXTENSION_CONTEXT, GURL())
+                  .is_available())
+        << "Test case (" << test.api_name << ", "
+        << static_cast<int>(test.current_session_type) << ").";
+  }
+}
+
 TEST(ExtensionAPITest, LazyGetSchema) {
   std::unique_ptr<ExtensionAPI> apis(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
@@ skipping 528 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions