OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/sessions/core/persistent_tab_restore_service.h" | 5 #include "components/sessions/core/persistent_tab_restore_service.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
(...skipping 18 matching lines...) Expand all Loading... |
29 #include "content/public/browser/navigation_controller.h" | 29 #include "content/public/browser/navigation_controller.h" |
30 #include "content/public/browser/navigation_entry.h" | 30 #include "content/public/browser/navigation_entry.h" |
31 #include "content/public/browser/notification_service.h" | 31 #include "content/public/browser/notification_service.h" |
32 #include "content/public/browser/notification_types.h" | 32 #include "content/public/browser/notification_types.h" |
33 #include "content/public/browser/web_contents.h" | 33 #include "content/public/browser/web_contents.h" |
34 #include "content/public/test/render_view_test.h" | 34 #include "content/public/test/render_view_test.h" |
35 #include "content/public/test/test_utils.h" | 35 #include "content/public/test/test_utils.h" |
36 #include "content/public/test/web_contents_tester.h" | 36 #include "content/public/test/web_contents_tester.h" |
37 #include "testing/gtest/include/gtest/gtest.h" | 37 #include "testing/gtest/include/gtest/gtest.h" |
38 | 38 |
39 typedef TabRestoreService::Tab Tab; | 39 typedef sessions::TabRestoreService::Tab Tab; |
40 typedef TabRestoreService::Window Window; | 40 typedef sessions::TabRestoreService::Window Window; |
41 | 41 |
42 using content::NavigationEntry; | 42 using content::NavigationEntry; |
43 using content::WebContentsTester; | 43 using content::WebContentsTester; |
44 using sessions::SerializedNavigationEntry; | 44 using sessions::SerializedNavigationEntry; |
45 using sessions::SerializedNavigationEntryTestHelper; | 45 using sessions::SerializedNavigationEntryTestHelper; |
46 | 46 |
47 // Create subclass that overrides TimeNow so that we can control the time used | 47 // Create subclass that overrides TimeNow so that we can control the time used |
48 // for closed tabs and windows. | 48 // for closed tabs and windows. |
49 class PersistentTabRestoreTimeFactory : public TabRestoreService::TimeFactory { | 49 class PersistentTabRestoreTimeFactory |
| 50 : public sessions::TabRestoreService::TimeFactory { |
50 public: | 51 public: |
51 PersistentTabRestoreTimeFactory() : time_(base::Time::Now()) {} | 52 PersistentTabRestoreTimeFactory() : time_(base::Time::Now()) {} |
52 | 53 |
53 ~PersistentTabRestoreTimeFactory() override {} | 54 ~PersistentTabRestoreTimeFactory() override {} |
54 | 55 |
55 base::Time TimeNow() override { return time_; } | 56 base::Time TimeNow() override { return time_; } |
56 | 57 |
57 private: | 58 private: |
58 base::Time time_; | 59 base::Time time_; |
59 }; | 60 }; |
60 | 61 |
61 class PersistentTabRestoreServiceTest : public ChromeRenderViewHostTestHarness { | 62 class PersistentTabRestoreServiceTest : public ChromeRenderViewHostTestHarness { |
62 public: | 63 public: |
63 PersistentTabRestoreServiceTest() | 64 PersistentTabRestoreServiceTest() |
64 : url1_("http://1"), | 65 : url1_("http://1"), |
65 url2_("http://2"), | 66 url2_("http://2"), |
66 url3_("http://3"), | 67 url3_("http://3"), |
67 user_agent_override_( | 68 user_agent_override_( |
68 "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.19" | 69 "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.19" |
69 " (KHTML, like Gecko) Chrome/18.0.1025.45 Safari/535.19"), | 70 " (KHTML, like Gecko) Chrome/18.0.1025.45 Safari/535.19"), |
70 time_factory_(NULL) { | 71 time_factory_(NULL) { |
71 } | 72 } |
72 | 73 |
73 ~PersistentTabRestoreServiceTest() override {} | 74 ~PersistentTabRestoreServiceTest() override {} |
74 | 75 |
75 protected: | 76 protected: |
76 enum { | 77 enum { |
77 kMaxEntries = TabRestoreServiceHelper::kMaxEntries, | 78 kMaxEntries = sessions::TabRestoreServiceHelper::kMaxEntries, |
78 }; | 79 }; |
79 | 80 |
80 // testing::Test: | 81 // testing::Test: |
81 void SetUp() override { | 82 void SetUp() override { |
82 ChromeRenderViewHostTestHarness::SetUp(); | 83 ChromeRenderViewHostTestHarness::SetUp(); |
83 live_tab_ = make_scoped_ptr(new sessions::ContentLiveTab(web_contents())); | 84 live_tab_ = make_scoped_ptr(new sessions::ContentLiveTab(web_contents())); |
84 time_factory_ = new PersistentTabRestoreTimeFactory(); | 85 time_factory_ = new PersistentTabRestoreTimeFactory(); |
85 service_.reset(new PersistentTabRestoreService( | 86 service_.reset(new sessions::PersistentTabRestoreService( |
86 make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())), | 87 make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())), |
87 time_factory_)); | 88 time_factory_)); |
88 } | 89 } |
89 | 90 |
90 void TearDown() override { | 91 void TearDown() override { |
91 service_->Shutdown(); | 92 service_->Shutdown(); |
92 service_.reset(); | 93 service_.reset(); |
93 delete time_factory_; | 94 delete time_factory_; |
94 ChromeRenderViewHostTestHarness::TearDown(); | 95 ChromeRenderViewHostTestHarness::TearDown(); |
95 } | 96 } |
96 | 97 |
97 TabRestoreService::Entries* mutable_entries() { | 98 sessions::TabRestoreService::Entries* mutable_entries() { |
98 return service_->mutable_entries(); | 99 return service_->mutable_entries(); |
99 } | 100 } |
100 | 101 |
101 void PruneEntries() { | 102 void PruneEntries() { |
102 service_->PruneEntries(); | 103 service_->PruneEntries(); |
103 } | 104 } |
104 | 105 |
105 void AddThreeNavigations() { | 106 void AddThreeNavigations() { |
106 // Navigate to three URLs. | 107 // Navigate to three URLs. |
107 NavigateAndCommit(url1_); | 108 NavigateAndCommit(url1_); |
108 NavigateAndCommit(url2_); | 109 NavigateAndCommit(url2_); |
109 NavigateAndCommit(url3_); | 110 NavigateAndCommit(url3_); |
110 } | 111 } |
111 | 112 |
112 void NavigateToIndex(int index) { | 113 void NavigateToIndex(int index) { |
113 // Navigate back. We have to do this song and dance as NavigationController | 114 // Navigate back. We have to do this song and dance as NavigationController |
114 // isn't happy if you navigate immediately while going back. | 115 // isn't happy if you navigate immediately while going back. |
115 controller().GoToIndex(index); | 116 controller().GoToIndex(index); |
116 WebContentsTester::For(web_contents())->CommitPendingNavigation(); | 117 WebContentsTester::For(web_contents())->CommitPendingNavigation(); |
117 } | 118 } |
118 | 119 |
119 void RecreateService() { | 120 void RecreateService() { |
120 // Must set service to null first so that it is destroyed before the new | 121 // Must set service to null first so that it is destroyed before the new |
121 // one is created. | 122 // one is created. |
122 service_->Shutdown(); | 123 service_->Shutdown(); |
123 content::RunAllBlockingPoolTasksUntilIdle(); | 124 content::RunAllBlockingPoolTasksUntilIdle(); |
124 service_.reset(); | 125 service_.reset(); |
125 service_.reset(new PersistentTabRestoreService( | 126 service_.reset(new sessions::PersistentTabRestoreService( |
126 make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())), | 127 make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())), |
127 time_factory_)); | 128 time_factory_)); |
128 SynchronousLoadTabsFromLastSession(); | 129 SynchronousLoadTabsFromLastSession(); |
129 } | 130 } |
130 | 131 |
131 // Adds a window with one tab and url to the profile's session service. | 132 // Adds a window with one tab and url to the profile's session service. |
132 // If |pinned| is true, the tab is marked as pinned in the session service. | 133 // If |pinned| is true, the tab is marked as pinned in the session service. |
133 void AddWindowWithOneTabToSessionService(bool pinned) { | 134 void AddWindowWithOneTabToSessionService(bool pinned) { |
134 SessionService* session_service = | 135 SessionService* session_service = |
135 SessionServiceFactory::GetForProfile(profile()); | 136 SessionServiceFactory::GetForProfile(profile()); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
169 content::RunAllBlockingPoolTasksUntilIdle(); | 170 content::RunAllBlockingPoolTasksUntilIdle(); |
170 } | 171 } |
171 | 172 |
172 sessions::LiveTab* live_tab() { return live_tab_.get(); } | 173 sessions::LiveTab* live_tab() { return live_tab_.get(); } |
173 | 174 |
174 GURL url1_; | 175 GURL url1_; |
175 GURL url2_; | 176 GURL url2_; |
176 GURL url3_; | 177 GURL url3_; |
177 std::string user_agent_override_; | 178 std::string user_agent_override_; |
178 scoped_ptr<sessions::LiveTab> live_tab_; | 179 scoped_ptr<sessions::LiveTab> live_tab_; |
179 scoped_ptr<PersistentTabRestoreService> service_; | 180 scoped_ptr<sessions::PersistentTabRestoreService> service_; |
180 PersistentTabRestoreTimeFactory* time_factory_; | 181 PersistentTabRestoreTimeFactory* time_factory_; |
181 }; | 182 }; |
182 | 183 |
183 namespace { | 184 namespace { |
184 | 185 |
185 class TestTabRestoreServiceObserver : public TabRestoreServiceObserver { | 186 class TestTabRestoreServiceObserver |
| 187 : public sessions::TabRestoreServiceObserver { |
186 public: | 188 public: |
187 TestTabRestoreServiceObserver() : got_loaded_(false) {} | 189 TestTabRestoreServiceObserver() : got_loaded_(false) {} |
188 | 190 |
189 void clear_got_loaded() { got_loaded_ = false; } | 191 void clear_got_loaded() { got_loaded_ = false; } |
190 bool got_loaded() const { return got_loaded_; } | 192 bool got_loaded() const { return got_loaded_; } |
191 | 193 |
192 // TabRestoreServiceObserver: | 194 // TabRestoreServiceObserver: |
193 void TabRestoreServiceChanged(TabRestoreService* service) override {} | 195 void TabRestoreServiceChanged(sessions::TabRestoreService* service) override { |
194 void TabRestoreServiceDestroyed(TabRestoreService* service) override {} | 196 } |
195 void TabRestoreServiceLoaded(TabRestoreService* service) override { | 197 void TabRestoreServiceDestroyed( |
| 198 sessions::TabRestoreService* service) override {} |
| 199 void TabRestoreServiceLoaded(sessions::TabRestoreService* service) override { |
196 got_loaded_ = true; | 200 got_loaded_ = true; |
197 } | 201 } |
198 | 202 |
199 private: | 203 private: |
200 // Was TabRestoreServiceLoaded() invoked? | 204 // Was TabRestoreServiceLoaded() invoked? |
201 bool got_loaded_; | 205 bool got_loaded_; |
202 | 206 |
203 DISALLOW_COPY_AND_ASSIGN(TestTabRestoreServiceObserver); | 207 DISALLOW_COPY_AND_ASSIGN(TestTabRestoreServiceObserver); |
204 }; | 208 }; |
205 | 209 |
206 } // namespace | 210 } // namespace |
207 | 211 |
208 TEST_F(PersistentTabRestoreServiceTest, Basic) { | 212 TEST_F(PersistentTabRestoreServiceTest, Basic) { |
209 AddThreeNavigations(); | 213 AddThreeNavigations(); |
210 | 214 |
211 // Have the service record the tab. | 215 // Have the service record the tab. |
212 service_->CreateHistoricalTab(live_tab(), -1); | 216 service_->CreateHistoricalTab(live_tab(), -1); |
213 | 217 |
214 // Make sure an entry was created. | 218 // Make sure an entry was created. |
215 ASSERT_EQ(1U, service_->entries().size()); | 219 ASSERT_EQ(1U, service_->entries().size()); |
216 | 220 |
217 // Make sure the entry matches. | 221 // Make sure the entry matches. |
218 TabRestoreService::Entry* entry = service_->entries().front(); | 222 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
219 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 223 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
220 Tab* tab = static_cast<Tab*>(entry); | 224 Tab* tab = static_cast<Tab*>(entry); |
221 EXPECT_FALSE(tab->pinned); | 225 EXPECT_FALSE(tab->pinned); |
222 EXPECT_TRUE(tab->extension_app_id.empty()); | 226 EXPECT_TRUE(tab->extension_app_id.empty()); |
223 ASSERT_EQ(3U, tab->navigations.size()); | 227 ASSERT_EQ(3U, tab->navigations.size()); |
224 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); | 228 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); |
225 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); | 229 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); |
226 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); | 230 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); |
227 EXPECT_EQ("", tab->user_agent_override); | 231 EXPECT_EQ("", tab->user_agent_override); |
228 EXPECT_EQ(2, tab->current_navigation_index); | 232 EXPECT_EQ(2, tab->current_navigation_index); |
229 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), | 233 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), |
230 tab->timestamp.ToInternalValue()); | 234 tab->timestamp.ToInternalValue()); |
231 | 235 |
232 NavigateToIndex(1); | 236 NavigateToIndex(1); |
233 | 237 |
234 // And check again, but set the user agent override this time. | 238 // And check again, but set the user agent override this time. |
235 web_contents()->SetUserAgentOverride(user_agent_override_); | 239 web_contents()->SetUserAgentOverride(user_agent_override_); |
236 service_->CreateHistoricalTab(live_tab(), -1); | 240 service_->CreateHistoricalTab(live_tab(), -1); |
237 | 241 |
238 // There should be two entries now. | 242 // There should be two entries now. |
239 ASSERT_EQ(2U, service_->entries().size()); | 243 ASSERT_EQ(2U, service_->entries().size()); |
240 | 244 |
241 // Make sure the entry matches. | 245 // Make sure the entry matches. |
242 entry = service_->entries().front(); | 246 entry = service_->entries().front(); |
243 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 247 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
244 tab = static_cast<Tab*>(entry); | 248 tab = static_cast<Tab*>(entry); |
245 EXPECT_FALSE(tab->pinned); | 249 EXPECT_FALSE(tab->pinned); |
246 ASSERT_EQ(3U, tab->navigations.size()); | 250 ASSERT_EQ(3U, tab->navigations.size()); |
247 EXPECT_EQ(url1_, tab->navigations[0].virtual_url()); | 251 EXPECT_EQ(url1_, tab->navigations[0].virtual_url()); |
248 EXPECT_EQ(url2_, tab->navigations[1].virtual_url()); | 252 EXPECT_EQ(url2_, tab->navigations[1].virtual_url()); |
249 EXPECT_EQ(url3_, tab->navigations[2].virtual_url()); | 253 EXPECT_EQ(url3_, tab->navigations[2].virtual_url()); |
250 EXPECT_EQ(user_agent_override_, tab->user_agent_override); | 254 EXPECT_EQ(user_agent_override_, tab->user_agent_override); |
251 EXPECT_EQ(1, tab->current_navigation_index); | 255 EXPECT_EQ(1, tab->current_navigation_index); |
252 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), | 256 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), |
253 tab->timestamp.ToInternalValue()); | 257 tab->timestamp.ToInternalValue()); |
(...skipping 13 matching lines...) Expand all Loading... |
267 // Have the service record the tab. | 271 // Have the service record the tab. |
268 service_->CreateHistoricalTab(live_tab(), -1); | 272 service_->CreateHistoricalTab(live_tab(), -1); |
269 | 273 |
270 // Recreate the service and have it load the tabs. | 274 // Recreate the service and have it load the tabs. |
271 RecreateService(); | 275 RecreateService(); |
272 | 276 |
273 // One entry should be created. | 277 // One entry should be created. |
274 ASSERT_EQ(1U, service_->entries().size()); | 278 ASSERT_EQ(1U, service_->entries().size()); |
275 | 279 |
276 // And verify the entry. | 280 // And verify the entry. |
277 PersistentTabRestoreService::Entry* entry = service_->entries().front(); | 281 sessions::PersistentTabRestoreService::Entry* entry = |
278 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 282 service_->entries().front(); |
| 283 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
279 Tab* tab = static_cast<Tab*>(entry); | 284 Tab* tab = static_cast<Tab*>(entry); |
280 EXPECT_FALSE(tab->pinned); | 285 EXPECT_FALSE(tab->pinned); |
281 ASSERT_EQ(3U, tab->navigations.size()); | 286 ASSERT_EQ(3U, tab->navigations.size()); |
282 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); | 287 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); |
283 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); | 288 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); |
284 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); | 289 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); |
285 EXPECT_EQ(2, tab->current_navigation_index); | 290 EXPECT_EQ(2, tab->current_navigation_index); |
286 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), | 291 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), |
287 tab->timestamp.ToInternalValue()); | 292 tab->timestamp.ToInternalValue()); |
288 } | 293 } |
289 | 294 |
290 // Tests restoring a single pinned tab. | 295 // Tests restoring a single pinned tab. |
291 TEST_F(PersistentTabRestoreServiceTest, RestorePinnedAndApp) { | 296 TEST_F(PersistentTabRestoreServiceTest, RestorePinnedAndApp) { |
292 AddThreeNavigations(); | 297 AddThreeNavigations(); |
293 | 298 |
294 // Have the service record the tab. | 299 // Have the service record the tab. |
295 service_->CreateHistoricalTab(live_tab(), -1); | 300 service_->CreateHistoricalTab(live_tab(), -1); |
296 | 301 |
297 // One entry should be created. | 302 // One entry should be created. |
298 ASSERT_EQ(1U, service_->entries().size()); | 303 ASSERT_EQ(1U, service_->entries().size()); |
299 | 304 |
300 // We have to explicitly mark the tab as pinned as there is no browser for | 305 // We have to explicitly mark the tab as pinned as there is no browser for |
301 // these tests. | 306 // these tests. |
302 TabRestoreService::Entry* entry = service_->entries().front(); | 307 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
303 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 308 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
304 Tab* tab = static_cast<Tab*>(entry); | 309 Tab* tab = static_cast<Tab*>(entry); |
305 tab->pinned = true; | 310 tab->pinned = true; |
306 const std::string extension_app_id("test"); | 311 const std::string extension_app_id("test"); |
307 tab->extension_app_id = extension_app_id; | 312 tab->extension_app_id = extension_app_id; |
308 | 313 |
309 // Recreate the service and have it load the tabs. | 314 // Recreate the service and have it load the tabs. |
310 RecreateService(); | 315 RecreateService(); |
311 | 316 |
312 // One entry should be created. | 317 // One entry should be created. |
313 ASSERT_EQ(1U, service_->entries().size()); | 318 ASSERT_EQ(1U, service_->entries().size()); |
314 | 319 |
315 // And verify the entry. | 320 // And verify the entry. |
316 entry = service_->entries().front(); | 321 entry = service_->entries().front(); |
317 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 322 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
318 tab = static_cast<Tab*>(entry); | 323 tab = static_cast<Tab*>(entry); |
319 EXPECT_TRUE(tab->pinned); | 324 EXPECT_TRUE(tab->pinned); |
320 ASSERT_EQ(3U, tab->navigations.size()); | 325 ASSERT_EQ(3U, tab->navigations.size()); |
321 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); | 326 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); |
322 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); | 327 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); |
323 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); | 328 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); |
324 EXPECT_EQ(2, tab->current_navigation_index); | 329 EXPECT_EQ(2, tab->current_navigation_index); |
325 EXPECT_TRUE(extension_app_id == tab->extension_app_id); | 330 EXPECT_TRUE(extension_app_id == tab->extension_app_id); |
326 } | 331 } |
327 | 332 |
328 // Make sure we persist entries to disk that have post data. | 333 // Make sure we persist entries to disk that have post data. |
329 TEST_F(PersistentTabRestoreServiceTest, DontPersistPostData) { | 334 TEST_F(PersistentTabRestoreServiceTest, DontPersistPostData) { |
330 AddThreeNavigations(); | 335 AddThreeNavigations(); |
331 controller().GetEntryAtIndex(0)->SetHasPostData(true); | 336 controller().GetEntryAtIndex(0)->SetHasPostData(true); |
332 controller().GetEntryAtIndex(1)->SetHasPostData(true); | 337 controller().GetEntryAtIndex(1)->SetHasPostData(true); |
333 controller().GetEntryAtIndex(2)->SetHasPostData(true); | 338 controller().GetEntryAtIndex(2)->SetHasPostData(true); |
334 | 339 |
335 // Have the service record the tab. | 340 // Have the service record the tab. |
336 service_->CreateHistoricalTab(live_tab(), -1); | 341 service_->CreateHistoricalTab(live_tab(), -1); |
337 ASSERT_EQ(1U, service_->entries().size()); | 342 ASSERT_EQ(1U, service_->entries().size()); |
338 | 343 |
339 // Recreate the service and have it load the tabs. | 344 // Recreate the service and have it load the tabs. |
340 RecreateService(); | 345 RecreateService(); |
341 | 346 |
342 // One entry should be created. | 347 // One entry should be created. |
343 ASSERT_EQ(1U, service_->entries().size()); | 348 ASSERT_EQ(1U, service_->entries().size()); |
344 | 349 |
345 const TabRestoreService::Entry* restored_entry = service_->entries().front(); | 350 const sessions::TabRestoreService::Entry* restored_entry = |
346 ASSERT_EQ(TabRestoreService::TAB, restored_entry->type); | 351 service_->entries().front(); |
| 352 ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type); |
347 | 353 |
348 const Tab* restored_tab = | 354 const Tab* restored_tab = |
349 static_cast<const Tab*>(restored_entry); | 355 static_cast<const Tab*>(restored_entry); |
350 // There should be 3 navs. | 356 // There should be 3 navs. |
351 ASSERT_EQ(3U, restored_tab->navigations.size()); | 357 ASSERT_EQ(3U, restored_tab->navigations.size()); |
352 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), | 358 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), |
353 restored_tab->timestamp.ToInternalValue()); | 359 restored_tab->timestamp.ToInternalValue()); |
354 } | 360 } |
355 | 361 |
356 // Make sure we don't persist entries to disk that have post data. This | 362 // Make sure we don't persist entries to disk that have post data. This |
(...skipping 25 matching lines...) Expand all Loading... |
382 EXPECT_FALSE(service_->IsLoaded()); | 388 EXPECT_FALSE(service_->IsLoaded()); |
383 | 389 |
384 TestTabRestoreServiceObserver observer; | 390 TestTabRestoreServiceObserver observer; |
385 service_->AddObserver(&observer); | 391 service_->AddObserver(&observer); |
386 SynchronousLoadTabsFromLastSession(); | 392 SynchronousLoadTabsFromLastSession(); |
387 EXPECT_TRUE(observer.got_loaded()); | 393 EXPECT_TRUE(observer.got_loaded()); |
388 service_->RemoveObserver(&observer); | 394 service_->RemoveObserver(&observer); |
389 | 395 |
390 // Make sure we get back one entry with one tab whose url is url1. | 396 // Make sure we get back one entry with one tab whose url is url1. |
391 ASSERT_EQ(1U, service_->entries().size()); | 397 ASSERT_EQ(1U, service_->entries().size()); |
392 TabRestoreService::Entry* entry2 = service_->entries().front(); | 398 sessions::TabRestoreService::Entry* entry2 = service_->entries().front(); |
393 ASSERT_EQ(TabRestoreService::WINDOW, entry2->type); | 399 ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry2->type); |
394 TabRestoreService::Window* window = | 400 sessions::TabRestoreService::Window* window = |
395 static_cast<TabRestoreService::Window*>(entry2); | 401 static_cast<sessions::TabRestoreService::Window*>(entry2); |
396 ASSERT_EQ(1U, window->tabs.size()); | 402 ASSERT_EQ(1U, window->tabs.size()); |
397 EXPECT_EQ(0, window->timestamp.ToInternalValue()); | 403 EXPECT_EQ(0, window->timestamp.ToInternalValue()); |
398 EXPECT_EQ(0, window->selected_tab_index); | 404 EXPECT_EQ(0, window->selected_tab_index); |
399 ASSERT_EQ(1U, window->tabs[0].navigations.size()); | 405 ASSERT_EQ(1U, window->tabs[0].navigations.size()); |
400 EXPECT_EQ(0, window->tabs[0].current_navigation_index); | 406 EXPECT_EQ(0, window->tabs[0].current_navigation_index); |
401 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); | 407 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); |
402 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); | 408 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); |
403 } | 409 } |
404 | 410 |
405 // Makes sure we don't attempt to load previous sessions after a restore. | 411 // Makes sure we don't attempt to load previous sessions after a restore. |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
441 AddThreeNavigations(); | 447 AddThreeNavigations(); |
442 | 448 |
443 service_->CreateHistoricalTab(live_tab(), -1); | 449 service_->CreateHistoricalTab(live_tab(), -1); |
444 | 450 |
445 RecreateService(); | 451 RecreateService(); |
446 | 452 |
447 // We should get back two entries, one from the previous session and one from | 453 // We should get back two entries, one from the previous session and one from |
448 // the tab restore service. The previous session entry should be first. | 454 // the tab restore service. The previous session entry should be first. |
449 ASSERT_EQ(2U, service_->entries().size()); | 455 ASSERT_EQ(2U, service_->entries().size()); |
450 // The first entry should come from the session service. | 456 // The first entry should come from the session service. |
451 TabRestoreService::Entry* entry = service_->entries().front(); | 457 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
452 ASSERT_EQ(TabRestoreService::WINDOW, entry->type); | 458 ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type); |
453 TabRestoreService::Window* window = | 459 sessions::TabRestoreService::Window* window = |
454 static_cast<TabRestoreService::Window*>(entry); | 460 static_cast<sessions::TabRestoreService::Window*>(entry); |
455 ASSERT_EQ(1U, window->tabs.size()); | 461 ASSERT_EQ(1U, window->tabs.size()); |
456 EXPECT_EQ(0, window->selected_tab_index); | 462 EXPECT_EQ(0, window->selected_tab_index); |
457 EXPECT_EQ(0, window->timestamp.ToInternalValue()); | 463 EXPECT_EQ(0, window->timestamp.ToInternalValue()); |
458 ASSERT_EQ(1U, window->tabs[0].navigations.size()); | 464 ASSERT_EQ(1U, window->tabs[0].navigations.size()); |
459 EXPECT_EQ(0, window->tabs[0].current_navigation_index); | 465 EXPECT_EQ(0, window->tabs[0].current_navigation_index); |
460 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); | 466 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); |
461 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); | 467 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); |
462 | 468 |
463 // Then the closed tab. | 469 // Then the closed tab. |
464 entry = *(++service_->entries().begin()); | 470 entry = *(++service_->entries().begin()); |
465 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 471 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
466 Tab* tab = static_cast<Tab*>(entry); | 472 Tab* tab = static_cast<Tab*>(entry); |
467 ASSERT_FALSE(tab->pinned); | 473 ASSERT_FALSE(tab->pinned); |
468 ASSERT_EQ(3U, tab->navigations.size()); | 474 ASSERT_EQ(3U, tab->navigations.size()); |
469 EXPECT_EQ(2, tab->current_navigation_index); | 475 EXPECT_EQ(2, tab->current_navigation_index); |
470 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), | 476 EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(), |
471 tab->timestamp.ToInternalValue()); | 477 tab->timestamp.ToInternalValue()); |
472 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); | 478 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); |
473 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); | 479 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); |
474 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); | 480 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); |
475 } | 481 } |
476 | 482 |
477 // Make sure pinned state is correctly loaded from session service. | 483 // Make sure pinned state is correctly loaded from session service. |
478 TEST_F(PersistentTabRestoreServiceTest, LoadPreviousSessionAndTabsPinned) { | 484 TEST_F(PersistentTabRestoreServiceTest, LoadPreviousSessionAndTabsPinned) { |
479 CreateSessionServiceWithOneWindow(true); | 485 CreateSessionServiceWithOneWindow(true); |
480 | 486 |
481 SessionServiceFactory::GetForProfile(profile())-> | 487 SessionServiceFactory::GetForProfile(profile())-> |
482 MoveCurrentSessionToLastSession(); | 488 MoveCurrentSessionToLastSession(); |
483 | 489 |
484 AddThreeNavigations(); | 490 AddThreeNavigations(); |
485 | 491 |
486 service_->CreateHistoricalTab(live_tab(), -1); | 492 service_->CreateHistoricalTab(live_tab(), -1); |
487 | 493 |
488 RecreateService(); | 494 RecreateService(); |
489 | 495 |
490 // We should get back two entries, one from the previous session and one from | 496 // We should get back two entries, one from the previous session and one from |
491 // the tab restore service. The previous session entry should be first. | 497 // the tab restore service. The previous session entry should be first. |
492 ASSERT_EQ(2U, service_->entries().size()); | 498 ASSERT_EQ(2U, service_->entries().size()); |
493 // The first entry should come from the session service. | 499 // The first entry should come from the session service. |
494 TabRestoreService::Entry* entry = service_->entries().front(); | 500 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
495 ASSERT_EQ(TabRestoreService::WINDOW, entry->type); | 501 ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type); |
496 TabRestoreService::Window* window = | 502 sessions::TabRestoreService::Window* window = |
497 static_cast<TabRestoreService::Window*>(entry); | 503 static_cast<sessions::TabRestoreService::Window*>(entry); |
498 ASSERT_EQ(1U, window->tabs.size()); | 504 ASSERT_EQ(1U, window->tabs.size()); |
499 EXPECT_EQ(0, window->selected_tab_index); | 505 EXPECT_EQ(0, window->selected_tab_index); |
500 EXPECT_TRUE(window->tabs[0].pinned); | 506 EXPECT_TRUE(window->tabs[0].pinned); |
501 ASSERT_EQ(1U, window->tabs[0].navigations.size()); | 507 ASSERT_EQ(1U, window->tabs[0].navigations.size()); |
502 EXPECT_EQ(0, window->tabs[0].current_navigation_index); | 508 EXPECT_EQ(0, window->tabs[0].current_navigation_index); |
503 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); | 509 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); |
504 | 510 |
505 // Then the closed tab. | 511 // Then the closed tab. |
506 entry = *(++service_->entries().begin()); | 512 entry = *(++service_->entries().begin()); |
507 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 513 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
508 Tab* tab = static_cast<Tab*>(entry); | 514 Tab* tab = static_cast<Tab*>(entry); |
509 ASSERT_FALSE(tab->pinned); | 515 ASSERT_FALSE(tab->pinned); |
510 ASSERT_EQ(3U, tab->navigations.size()); | 516 ASSERT_EQ(3U, tab->navigations.size()); |
511 EXPECT_EQ(2, tab->current_navigation_index); | 517 EXPECT_EQ(2, tab->current_navigation_index); |
512 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); | 518 EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url()); |
513 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); | 519 EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url()); |
514 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); | 520 EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url()); |
515 } | 521 } |
516 | 522 |
517 // Creates kMaxEntries + 1 windows in the session service and makes sure we only | 523 // Creates kMaxEntries + 1 windows in the session service and makes sure we only |
(...skipping 11 matching lines...) Expand all Loading... |
529 | 535 |
530 service_->CreateHistoricalTab(live_tab(), -1); | 536 service_->CreateHistoricalTab(live_tab(), -1); |
531 | 537 |
532 RecreateService(); | 538 RecreateService(); |
533 | 539 |
534 // We should get back kMaxEntries entries. We added more, but | 540 // We should get back kMaxEntries entries. We added more, but |
535 // TabRestoreService only allows up to kMaxEntries. | 541 // TabRestoreService only allows up to kMaxEntries. |
536 ASSERT_EQ(kMaxEntries, service_->entries().size()); | 542 ASSERT_EQ(kMaxEntries, service_->entries().size()); |
537 | 543 |
538 // The first entry should come from the session service. | 544 // The first entry should come from the session service. |
539 TabRestoreService::Entry* entry = service_->entries().front(); | 545 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
540 ASSERT_EQ(TabRestoreService::WINDOW, entry->type); | 546 ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type); |
541 TabRestoreService::Window* window = | 547 sessions::TabRestoreService::Window* window = |
542 static_cast<TabRestoreService::Window*>(entry); | 548 static_cast<sessions::TabRestoreService::Window*>(entry); |
543 ASSERT_EQ(1U, window->tabs.size()); | 549 ASSERT_EQ(1U, window->tabs.size()); |
544 EXPECT_EQ(0, window->selected_tab_index); | 550 EXPECT_EQ(0, window->selected_tab_index); |
545 EXPECT_EQ(0, window->timestamp.ToInternalValue()); | 551 EXPECT_EQ(0, window->timestamp.ToInternalValue()); |
546 ASSERT_EQ(1U, window->tabs[0].navigations.size()); | 552 ASSERT_EQ(1U, window->tabs[0].navigations.size()); |
547 EXPECT_EQ(0, window->tabs[0].current_navigation_index); | 553 EXPECT_EQ(0, window->tabs[0].current_navigation_index); |
548 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); | 554 EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue()); |
549 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); | 555 EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url()); |
550 } | 556 } |
551 | 557 |
552 // Makes sure we restore timestamps correctly. | 558 // Makes sure we restore timestamps correctly. |
553 TEST_F(PersistentTabRestoreServiceTest, TimestampSurvivesRestore) { | 559 TEST_F(PersistentTabRestoreServiceTest, TimestampSurvivesRestore) { |
554 base::Time tab_timestamp(base::Time::FromInternalValue(123456789)); | 560 base::Time tab_timestamp(base::Time::FromInternalValue(123456789)); |
555 | 561 |
556 AddThreeNavigations(); | 562 AddThreeNavigations(); |
557 | 563 |
558 // Have the service record the tab. | 564 // Have the service record the tab. |
559 service_->CreateHistoricalTab(live_tab(), -1); | 565 service_->CreateHistoricalTab(live_tab(), -1); |
560 | 566 |
561 // Make sure an entry was created. | 567 // Make sure an entry was created. |
562 ASSERT_EQ(1U, service_->entries().size()); | 568 ASSERT_EQ(1U, service_->entries().size()); |
563 | 569 |
564 // Make sure the entry matches. | 570 // Make sure the entry matches. |
565 std::vector<SerializedNavigationEntry> old_navigations; | 571 std::vector<SerializedNavigationEntry> old_navigations; |
566 { | 572 { |
567 // |entry|/|tab| doesn't survive after RecreateService(). | 573 // |entry|/|tab| doesn't survive after RecreateService(). |
568 TabRestoreService::Entry* entry = service_->entries().front(); | 574 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
569 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 575 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
570 Tab* tab = static_cast<Tab*>(entry); | 576 Tab* tab = static_cast<Tab*>(entry); |
571 tab->timestamp = tab_timestamp; | 577 tab->timestamp = tab_timestamp; |
572 old_navigations = tab->navigations; | 578 old_navigations = tab->navigations; |
573 } | 579 } |
574 | 580 |
575 EXPECT_EQ(3U, old_navigations.size()); | 581 EXPECT_EQ(3U, old_navigations.size()); |
576 for (size_t i = 0; i < old_navigations.size(); ++i) { | 582 for (size_t i = 0; i < old_navigations.size(); ++i) { |
577 EXPECT_FALSE(old_navigations[i].timestamp().is_null()); | 583 EXPECT_FALSE(old_navigations[i].timestamp().is_null()); |
578 } | 584 } |
579 | 585 |
580 // Set this, otherwise previous session won't be loaded. | 586 // Set this, otherwise previous session won't be loaded. |
581 profile()->set_last_session_exited_cleanly(false); | 587 profile()->set_last_session_exited_cleanly(false); |
582 | 588 |
583 RecreateService(); | 589 RecreateService(); |
584 | 590 |
585 // One entry should be created. | 591 // One entry should be created. |
586 ASSERT_EQ(1U, service_->entries().size()); | 592 ASSERT_EQ(1U, service_->entries().size()); |
587 | 593 |
588 // And verify the entry. | 594 // And verify the entry. |
589 TabRestoreService::Entry* restored_entry = service_->entries().front(); | 595 sessions::TabRestoreService::Entry* restored_entry = |
590 ASSERT_EQ(TabRestoreService::TAB, restored_entry->type); | 596 service_->entries().front(); |
| 597 ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type); |
591 Tab* restored_tab = | 598 Tab* restored_tab = |
592 static_cast<Tab*>(restored_entry); | 599 static_cast<Tab*>(restored_entry); |
593 EXPECT_EQ(tab_timestamp.ToInternalValue(), | 600 EXPECT_EQ(tab_timestamp.ToInternalValue(), |
594 restored_tab->timestamp.ToInternalValue()); | 601 restored_tab->timestamp.ToInternalValue()); |
595 ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size()); | 602 ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size()); |
596 for (size_t i = 0; i < restored_tab->navigations.size(); ++i) { | 603 for (size_t i = 0; i < restored_tab->navigations.size(); ++i) { |
597 EXPECT_EQ(old_navigations[i].timestamp(), | 604 EXPECT_EQ(old_navigations[i].timestamp(), |
598 restored_tab->navigations[i].timestamp()); | 605 restored_tab->navigations[i].timestamp()); |
599 } | 606 } |
600 } | 607 } |
601 | 608 |
602 // Makes sure we restore status codes correctly. | 609 // Makes sure we restore status codes correctly. |
603 TEST_F(PersistentTabRestoreServiceTest, StatusCodesSurviveRestore) { | 610 TEST_F(PersistentTabRestoreServiceTest, StatusCodesSurviveRestore) { |
604 AddThreeNavigations(); | 611 AddThreeNavigations(); |
605 | 612 |
606 // Have the service record the tab. | 613 // Have the service record the tab. |
607 service_->CreateHistoricalTab(live_tab(), -1); | 614 service_->CreateHistoricalTab(live_tab(), -1); |
608 | 615 |
609 // Make sure an entry was created. | 616 // Make sure an entry was created. |
610 ASSERT_EQ(1U, service_->entries().size()); | 617 ASSERT_EQ(1U, service_->entries().size()); |
611 | 618 |
612 // Make sure the entry matches. | 619 // Make sure the entry matches. |
613 std::vector<sessions::SerializedNavigationEntry> old_navigations; | 620 std::vector<sessions::SerializedNavigationEntry> old_navigations; |
614 { | 621 { |
615 // |entry|/|tab| doesn't survive after RecreateService(). | 622 // |entry|/|tab| doesn't survive after RecreateService(). |
616 TabRestoreService::Entry* entry = service_->entries().front(); | 623 sessions::TabRestoreService::Entry* entry = service_->entries().front(); |
617 ASSERT_EQ(TabRestoreService::TAB, entry->type); | 624 ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type); |
618 Tab* tab = static_cast<Tab*>(entry); | 625 Tab* tab = static_cast<Tab*>(entry); |
619 old_navigations = tab->navigations; | 626 old_navigations = tab->navigations; |
620 } | 627 } |
621 | 628 |
622 EXPECT_EQ(3U, old_navigations.size()); | 629 EXPECT_EQ(3U, old_navigations.size()); |
623 for (size_t i = 0; i < old_navigations.size(); ++i) { | 630 for (size_t i = 0; i < old_navigations.size(); ++i) { |
624 EXPECT_EQ(200, old_navigations[i].http_status_code()); | 631 EXPECT_EQ(200, old_navigations[i].http_status_code()); |
625 } | 632 } |
626 | 633 |
627 // Set this, otherwise previous session won't be loaded. | 634 // Set this, otherwise previous session won't be loaded. |
628 profile()->set_last_session_exited_cleanly(false); | 635 profile()->set_last_session_exited_cleanly(false); |
629 | 636 |
630 RecreateService(); | 637 RecreateService(); |
631 | 638 |
632 // One entry should be created. | 639 // One entry should be created. |
633 ASSERT_EQ(1U, service_->entries().size()); | 640 ASSERT_EQ(1U, service_->entries().size()); |
634 | 641 |
635 // And verify the entry. | 642 // And verify the entry. |
636 TabRestoreService::Entry* restored_entry = service_->entries().front(); | 643 sessions::TabRestoreService::Entry* restored_entry = |
637 ASSERT_EQ(TabRestoreService::TAB, restored_entry->type); | 644 service_->entries().front(); |
| 645 ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type); |
638 Tab* restored_tab = | 646 Tab* restored_tab = |
639 static_cast<Tab*>(restored_entry); | 647 static_cast<Tab*>(restored_entry); |
640 ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size()); | 648 ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size()); |
641 for (size_t i = 0; i < restored_tab->navigations.size(); ++i) { | 649 for (size_t i = 0; i < restored_tab->navigations.size(); ++i) { |
642 EXPECT_EQ(200, restored_tab->navigations[i].http_status_code()); | 650 EXPECT_EQ(200, restored_tab->navigations[i].http_status_code()); |
643 } | 651 } |
644 } | 652 } |
645 | 653 |
646 TEST_F(PersistentTabRestoreServiceTest, PruneEntries) { | 654 TEST_F(PersistentTabRestoreServiceTest, PruneEntries) { |
647 service_->ClearEntries(); | 655 service_->ClearEntries(); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
765 | 773 |
766 EXPECT_FALSE(service_->IsLoaded()); | 774 EXPECT_FALSE(service_->IsLoaded()); |
767 TestTabRestoreServiceObserver observer; | 775 TestTabRestoreServiceObserver observer; |
768 service_->AddObserver(&observer); | 776 service_->AddObserver(&observer); |
769 EXPECT_EQ(max_entries, service_->entries().size()); | 777 EXPECT_EQ(max_entries, service_->entries().size()); |
770 SynchronousLoadTabsFromLastSession(); | 778 SynchronousLoadTabsFromLastSession(); |
771 EXPECT_TRUE(observer.got_loaded()); | 779 EXPECT_TRUE(observer.got_loaded()); |
772 EXPECT_TRUE(service_->IsLoaded()); | 780 EXPECT_TRUE(service_->IsLoaded()); |
773 service_->RemoveObserver(&observer); | 781 service_->RemoveObserver(&observer); |
774 } | 782 } |
OLD | NEW |