Introduce lock screen app context to extension features

extensions/browser/process_map_unittest.cc

 // Copyright 2013 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/browser/process_map.h"
 
+#include "base/memory/ref_counted.h"
+#include "base/values.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/features/feature.h"
+#include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace extensions {
+namespace {
+
+enum class TypeToCreate { kExtension, kHostedApp, kPlatformApp };
+
+scoped_refptr<const Extension> CreateExtensionWithFlags(TypeToCreate type,
+                                                        const std::string& id,
+                                                        int flags) {
+  DictionaryBuilder manifest_builder;
+  manifest_builder.Set("name", "Test extension")
+      .Set("version", "1.0")
+      .Set("manifest_version", 2);
+
+  if (type == TypeToCreate::kExtension) {
+    manifest_builder.Set(
+        "background",
+        DictionaryBuilder()
+            .Set("scripts", ListBuilder().Append("background.js").Build())
+            .Build());
+  } else if (type == TypeToCreate::kHostedApp) {
+    manifest_builder.Set(
+        "app", DictionaryBuilder()
+                   .Set("launch", DictionaryBuilder()
+                                      .Set("web_url", "https://www.foo.bar")
+                                      .Build())
+                   .Build());
+  } else if (type == TypeToCreate::kPlatformApp) {
+    manifest_builder.Set(
+        "app", DictionaryBuilder()
+                   .Set("background",
+                        DictionaryBuilder()
+                            .Set("scripts",
+                                 ListBuilder().Append("background.js").Build())
+                            .Build())
+                   .Build());
+  }
+
+  return ExtensionBuilder()
+      .SetID(id)
+      .AddFlags(flags)
+      .SetManifest(manifest_builder.Build())
+      .Build();
+}
+
+}  // namespace
+}  // namespace extensions
+
 using extensions::ProcessMap;
 
 TEST(ExtensionProcessMapTest, Test) {
   ProcessMap map;
 
   // Test behavior when empty.
   EXPECT_FALSE(map.Contains("a", 1));
   EXPECT_FALSE(map.Remove("a", 1, 1));
   EXPECT_EQ(0u, map.size());
 
@@ skipping 37 matching lines @@
 
   EXPECT_TRUE(map.Remove("a", 1, 5));
   EXPECT_EQ(3u, map.size());
   EXPECT_FALSE(map.Contains("a", 1));
 
   EXPECT_EQ(2, map.RemoveAllFromProcess(2));
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(0, map.RemoveAllFromProcess(2));
   EXPECT_EQ(1u, map.size());
 }
+
+TEST(ExtensionProcessMapTest, GetMostLikelyContextType) {
+  ProcessMap map;
+
+  EXPECT_EQ(extensions::Feature::WEB_PAGE_CONTEXT,
+            map.GetMostLikelyContextType(nullptr, 1));
+
+  scoped_refptr<const extensions::Extension> extension =
+      CreateExtensionWithFlags(extensions::TypeToCreate::kExtension, "a",
+                               extensions::Extension::NO_FLAGS);
+
+  EXPECT_EQ(extensions::Feature::CONTENT_SCRIPT_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 2));
+
+  map.Insert("b", 3, 1);
+  extension = CreateExtensionWithFlags(extensions::TypeToCreate::kExtension,
+                                       "b", extensions::Extension::NO_FLAGS);
+  EXPECT_EQ(extensions::Feature::BLESSED_EXTENSION_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 3));
+
+  map.Insert("c", 4, 2);
+  extension = CreateExtensionWithFlags(extensions::TypeToCreate::kPlatformApp,
+                                       "c", extensions::Extension::NO_FLAGS);
+  EXPECT_EQ(extensions::Feature::BLESSED_EXTENSION_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 4));
+
+  map.Insert("d", 5, 3);
+  extension =
+      CreateExtensionWithFlags(extensions::TypeToCreate::kPlatformApp, "d",
+                               extensions::Extension::RUNS_ON_LOCK_SCREEN);
+  EXPECT_EQ(extensions::Feature::LOCK_SCREEN_EXTENSION_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 5));
+
+  map.Insert("e", 6, 4);
+  extension =
+      CreateExtensionWithFlags(extensions::TypeToCreate::kExtension, "e",
+                               extensions::Extension::RUNS_ON_LOCK_SCREEN);
+  EXPECT_EQ(extensions::Feature::LOCK_SCREEN_EXTENSION_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 6));
+
+  map.Insert("f", 7, 5);
+  extension =
+      CreateExtensionWithFlags(extensions::TypeToCreate::kHostedApp, "f",
+                               extensions::Extension::RUNS_ON_LOCK_SCREEN);
+  EXPECT_EQ(extensions::Feature::BLESSED_WEB_PAGE_CONTEXT,
+            map.GetMostLikelyContextType(extension.get(), 7));
+}