1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "extensions/browser/mojo/keep_alive_impl.h"
6
7 #include <utility>
8
9 #include "base/macros.h"
10 #include "base/run_loop.h"
11 #include "extensions/browser/extension_registry.h"
12 #include "extensions/browser/extensions_test.h"
13 #include "extensions/browser/process_manager.h"
14 #include "extensions/browser/unloaded_extension_reason.h"
15 #include "extensions/common/extension_builder.h"
16 #include "mojo/public/cpp/bindings/pending_remote.h"
17 #include "mojo/public/cpp/bindings/remote.h"
18
19 namespace extensions {
20
21 class KeepAliveTest : public ExtensionsTest {
22 public:
KeepAliveTest()23 KeepAliveTest() : mojo_activity_(Activity::MOJO, "") {}
~KeepAliveTest()24 ~KeepAliveTest() override {}
25
SetUp()26 void SetUp() override {
27 ExtensionsTest::SetUp();
28 extension_ =
29 ExtensionBuilder()
30 .SetManifest(
31 DictionaryBuilder()
32 .Set("name", "app")
33 .Set("version", "1")
34 .Set("manifest_version", 2)
35 .Set("app", DictionaryBuilder()
36 .Set("background",
37 DictionaryBuilder()
38 .Set("scripts",
39 ListBuilder()
40 .Append("background.js")
41 .Build())
42 .Build())
43 .Build())
44 .Build())
45 .SetID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
46 .Build();
47 }
48
WaitUntilLazyKeepAliveChanges()49 void WaitUntilLazyKeepAliveChanges() {
50 int initial_keep_alive_count = GetKeepAliveCount();
51 while (GetKeepAliveCount() == initial_keep_alive_count) {
52 base::RunLoop().RunUntilIdle();
53 }
54 }
55
CreateKeepAlive(mojo::PendingReceiver<KeepAlive> receiver)56 void CreateKeepAlive(mojo::PendingReceiver<KeepAlive> receiver) {
57 KeepAliveImpl::Create(browser_context(), extension_.get(), nullptr,
58 std::move(receiver));
59 }
60
extension()61 const Extension* extension() { return extension_.get(); }
62
GetKeepAliveCount()63 int GetKeepAliveCount() {
64 return ProcessManager::Get(browser_context())
65 ->GetLazyKeepaliveCount(extension());
66 }
67
68 using ActivitiesMultiset = ProcessManager::ActivitiesMultiset;
69
70 const std::pair<Activity::Type, std::string> mojo_activity_;
71
GetActivities()72 ActivitiesMultiset GetActivities() {
73 return ProcessManager::Get(browser_context())
74 ->GetLazyKeepaliveActivities(extension());
75 }
76
77 private:
78 scoped_refptr<const Extension> extension_;
79
80 DISALLOW_COPY_AND_ASSIGN(KeepAliveTest);
81 };
82
TEST_F(KeepAliveTest,Basic)83 TEST_F(KeepAliveTest, Basic) {
84 mojo::PendingRemote<KeepAlive> keep_alive;
85 CreateKeepAlive(keep_alive.InitWithNewPipeAndPassReceiver());
86 EXPECT_EQ(1, GetKeepAliveCount());
87 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
88
89 keep_alive.reset();
90 WaitUntilLazyKeepAliveChanges();
91 EXPECT_EQ(0, GetKeepAliveCount());
92 EXPECT_EQ(0u, GetActivities().count(mojo_activity_));
93 }
94
TEST_F(KeepAliveTest,TwoKeepAlives)95 TEST_F(KeepAliveTest, TwoKeepAlives) {
96 mojo::PendingRemote<KeepAlive> keep_alive;
97 CreateKeepAlive(keep_alive.InitWithNewPipeAndPassReceiver());
98 EXPECT_EQ(1, GetKeepAliveCount());
99 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
100
101 mojo::PendingRemote<KeepAlive> other_keep_alive;
102 CreateKeepAlive(other_keep_alive.InitWithNewPipeAndPassReceiver());
103 EXPECT_EQ(2, GetKeepAliveCount());
104 EXPECT_EQ(2u, GetActivities().count(mojo_activity_));
105
106 keep_alive.reset();
107 WaitUntilLazyKeepAliveChanges();
108 EXPECT_EQ(1, GetKeepAliveCount());
109 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
110
111 other_keep_alive.reset();
112 WaitUntilLazyKeepAliveChanges();
113 EXPECT_EQ(0, GetKeepAliveCount());
114 EXPECT_EQ(0u, GetActivities().count(mojo_activity_));
115 }
116
TEST_F(KeepAliveTest,UnloadExtension)117 TEST_F(KeepAliveTest, UnloadExtension) {
118 mojo::Remote<KeepAlive> keep_alive;
119 CreateKeepAlive(keep_alive.BindNewPipeAndPassReceiver());
120 EXPECT_EQ(1, GetKeepAliveCount());
121 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
122
123 scoped_refptr<const Extension> other_extension =
124 ExtensionBuilder()
125 .SetManifest(
126 DictionaryBuilder()
127 .Set("name", "app")
128 .Set("version", "1")
129 .Set("manifest_version", 2)
130 .Set("app",
131 DictionaryBuilder()
132 .Set("background",
133 DictionaryBuilder()
134 .Set("scripts", ListBuilder()
135 .Append("background.js")
136 .Build())
137 .Build())
138 .Build())
139 .Build())
140 .SetID("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
141 .Build();
142
143 ExtensionRegistry::Get(browser_context())
144 ->TriggerOnUnloaded(other_extension.get(),
145 UnloadedExtensionReason::DISABLE);
146 EXPECT_EQ(1, GetKeepAliveCount());
147 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
148
149 ExtensionRegistry::Get(browser_context())
150 ->TriggerOnUnloaded(extension(), UnloadedExtensionReason::DISABLE);
151 // When its extension is unloaded, the KeepAliveImpl should not modify the
152 // keep-alive count for its extension. However, ProcessManager resets its
153 // keep-alive count for an unloaded extension.
154 EXPECT_EQ(0, GetKeepAliveCount());
155 EXPECT_EQ(0u, GetActivities().count(mojo_activity_));
156
157 // Wait for |keep_alive| to disconnect.
158 base::RunLoop run_loop;
159 keep_alive.set_disconnect_handler(run_loop.QuitClosure());
160 run_loop.Run();
161 }
162
TEST_F(KeepAliveTest,Shutdown)163 TEST_F(KeepAliveTest, Shutdown) {
164 mojo::Remote<KeepAlive> keep_alive;
165 CreateKeepAlive(keep_alive.BindNewPipeAndPassReceiver());
166 EXPECT_EQ(1, GetKeepAliveCount());
167 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
168
169 ExtensionRegistry::Get(browser_context())->Shutdown();
170 // After a shutdown event, the KeepAliveImpl should not access its
171 // ProcessManager and so the keep-alive count should remain unchanged.
172 EXPECT_EQ(1, GetKeepAliveCount());
173 EXPECT_EQ(1u, GetActivities().count(mojo_activity_));
174
175 // Wait for |keep_alive| to disconnect.
176 base::RunLoop run_loop;
177 keep_alive.set_disconnect_handler(run_loop.QuitClosure());
178 run_loop.Run();
179 }
180
181 } // namespace extensions
182