| // Copyright 2015 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/extension_api_frame_id_map.h" |
| |
| #include "base/bind.h" |
| #include "base/run_loop.h" |
| #include "base/strings/stringprintf.h" |
| #include "content/public/test/test_browser_thread_bundle.h" |
| #include "extensions/common/constants.h" |
| #include "ipc/ipc_message.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| using FrameDataCallback = extensions::ExtensionApiFrameIdMap::FrameDataCallback; |
| |
| int ToTestFrameId(int render_process_id, int frame_routing_id) { |
| if (render_process_id < 0 && frame_routing_id < 0) |
| return ExtensionApiFrameIdMap::kInvalidFrameId; |
| // Return a deterministic value (yet different from the input) for testing. |
| // To make debugging easier: Ending with 0 = frame ID. |
| return render_process_id * 1000 + frame_routing_id * 10; |
| } |
| |
| int ToTestParentFrameId(int render_process_id, int frame_routing_id) { |
| if (render_process_id < 0 && frame_routing_id < 0) |
| return ExtensionApiFrameIdMap::kInvalidFrameId; |
| // Return a deterministic value (yet different from the input) for testing. |
| // To make debugging easier: Ending with 7 = parent frame ID. |
| return render_process_id * 1000 + frame_routing_id * 10 + 7; |
| } |
| |
| int ToTestTabId(int render_process_id, int frame_routing_id) { |
| if (render_process_id < 0 && frame_routing_id < 0) |
| return extension_misc::kUnknownTabId; |
| // Return a deterministic value (yet different from the input) for testing. |
| // To make debugging easier: Ending with 5 = tab ID. |
| return render_process_id * 1000 + frame_routing_id * 10 + 5; |
| } |
| |
| int ToTestWindowId(int render_process_id, int frame_routing_id) { |
| if (render_process_id < 0 && frame_routing_id < 0) |
| return extension_misc::kUnknownWindowId; |
| // Return a deterministic value (yet different from the input) for testing. |
| // To make debugging easier: Ending with 4 = window ID. |
| return render_process_id * 1000 + frame_routing_id * 10 + 4; |
| } |
| |
| GURL ToTestLastCommittedMainFrameURL(int render_process_id, |
| int frame_routing_id) { |
| if (render_process_id < 0 && frame_routing_id < 0) |
| return GURL(); |
| |
| // Return a deterministic value (yet different from the input) for testing. |
| return GURL(base::StringPrintf("http://%d.com/%d", render_process_id, |
| frame_routing_id)); |
| } |
| |
| class TestExtensionApiFrameIdMap : public ExtensionApiFrameIdMap { |
| public: |
| TestExtensionApiFrameIdMap() {} |
| ~TestExtensionApiFrameIdMap() override {} |
| |
| int GetInternalSize() { return frame_data_map_.size(); } |
| int GetInternalCallbackCount() { |
| int count = 0; |
| for (auto& it : callbacks_map_) |
| count += it.second.callbacks.size(); |
| return count; |
| } |
| |
| // These indirections are used because we cannot mock RenderFrameHost with |
| // fixed IDs in unit tests. |
| // TODO(robwu): Use content/public/test/test_renderer_host.h to mock |
| // RenderFrameHosts and update the tests to test against these mocks. |
| // After doing that, there is no need for CacheFrameData/RemoveFrameData |
| // methods that take a RenderFrameIdKey, so the methods can be merged. |
| void SetInternalFrameData(int render_process_id, int frame_routing_id) { |
| CacheFrameData(RenderFrameIdKey(render_process_id, frame_routing_id)); |
| } |
| void RemoveInternalFrameData(int render_process_id, int frame_routing_id) { |
| RemoveFrameData(RenderFrameIdKey(render_process_id, frame_routing_id)); |
| } |
| |
| private: |
| // ExtensionApiFrameIdMap: |
| FrameData KeyToValue(const RenderFrameIdKey& key) const override { |
| return FrameData( |
| ToTestFrameId(key.render_process_id, key.frame_routing_id), |
| ToTestParentFrameId(key.render_process_id, key.frame_routing_id), |
| ToTestTabId(key.render_process_id, key.frame_routing_id), |
| ToTestWindowId(key.render_process_id, key.frame_routing_id), |
| ToTestLastCommittedMainFrameURL(key.render_process_id, |
| key.frame_routing_id)); |
| } |
| }; |
| |
| class ExtensionApiFrameIdMapTest : public testing::Test { |
| public: |
| ExtensionApiFrameIdMapTest() |
| : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} |
| |
| FrameDataCallback CreateCallback( |
| int render_process_id, |
| int frame_routing_id, |
| const std::string& callback_name_for_testing) { |
| return base::Bind(&ExtensionApiFrameIdMapTest::OnCalledCallback, |
| base::Unretained(this), render_process_id, |
| frame_routing_id, callback_name_for_testing); |
| } |
| |
| void OnCalledCallback(int render_process_id, |
| int frame_routing_id, |
| const std::string& callback_name_for_testing, |
| const ExtensionApiFrameIdMap::FrameData& frame_data) { |
| results_.push_back(callback_name_for_testing); |
| |
| // If this fails, then the mapping is completely wrong. |
| EXPECT_EQ(ToTestFrameId(render_process_id, frame_routing_id), |
| frame_data.frame_id); |
| EXPECT_EQ(ToTestParentFrameId(render_process_id, frame_routing_id), |
| frame_data.parent_frame_id); |
| EXPECT_EQ(ToTestTabId(render_process_id, frame_routing_id), |
| frame_data.tab_id); |
| EXPECT_EQ(ToTestWindowId(render_process_id, frame_routing_id), |
| frame_data.window_id); |
| EXPECT_EQ( |
| ToTestLastCommittedMainFrameURL(render_process_id, frame_routing_id), |
| frame_data.last_committed_main_frame_url); |
| } |
| |
| const std::vector<std::string>& results() { return results_; } |
| void ClearResults() { results_.clear(); } |
| |
| private: |
| content::TestBrowserThreadBundle thread_bundle_; |
| // Used to verify the order of callbacks. |
| std::vector<std::string> results_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ExtensionApiFrameIdMapTest); |
| }; |
| |
| } // namespace |
| |
| TEST_F(ExtensionApiFrameIdMapTest, GetFrameDataOnIO) { |
| TestExtensionApiFrameIdMap map; |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| // Two identical calls, should be processed at the next message loop. |
| map.GetFrameDataOnIO(1, 2, CreateCallback(1, 2, "first")); |
| EXPECT_EQ(1, map.GetInternalCallbackCount()); |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| map.GetFrameDataOnIO(1, 2, CreateCallback(1, 2, "first again")); |
| EXPECT_EQ(2, map.GetInternalCallbackCount()); |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| // First get the frame ID on IO (queued on message loop), then set it on UI. |
| // No callbacks should be invoked because the IO thread cannot know that the |
| // frame ID was set on the UI thread. |
| map.GetFrameDataOnIO(2, 1, CreateCallback(2, 1, "something else")); |
| EXPECT_EQ(3, map.GetInternalCallbackCount()); |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| map.SetInternalFrameData(2, 1); |
| EXPECT_EQ(1, map.GetInternalSize()); |
| EXPECT_EQ(0U, results().size()); |
| |
| // Run some self-contained test. They should not affect the above callbacks. |
| { |
| // Callbacks for invalid IDs should immediately be run because it doesn't |
| // require a thread hop to determine their invalidity. |
| map.GetFrameDataOnIO(-1, MSG_ROUTING_NONE, |
| CreateCallback(-1, MSG_ROUTING_NONE, "invalid IDs")); |
| EXPECT_EQ(3, map.GetInternalCallbackCount()); // No change. |
| EXPECT_EQ(1, map.GetInternalSize()); // No change. |
| ASSERT_EQ(1U, results().size()); // +1 |
| EXPECT_EQ("invalid IDs", results()[0]); |
| ClearResults(); |
| } |
| |
| { |
| // First set the frame ID on UI, then get it on IO. Callback should |
| // immediately be invoked. |
| map.SetInternalFrameData(3, 1); |
| EXPECT_EQ(2, map.GetInternalSize()); |
| |
| map.GetFrameDataOnIO(3, 1, CreateCallback(3, 1, "the only result")); |
| EXPECT_EQ(3, map.GetInternalCallbackCount()); // No change. |
| EXPECT_EQ(2, map.GetInternalSize()); // +1 |
| ASSERT_EQ(1U, results().size()); // +1 |
| EXPECT_EQ("the only result", results()[0]); |
| ClearResults(); |
| } |
| |
| { |
| // Request the frame ID on IO, set the frame ID (in reality, set on the UI), |
| // and request another frame ID. The last query should cause both callbacks |
| // to run because the frame ID is known at the time of the call. |
| map.GetFrameDataOnIO(7, 2, CreateCallback(7, 2, "queued")); |
| EXPECT_EQ(4, map.GetInternalCallbackCount()); // +1 |
| |
| map.SetInternalFrameData(7, 2); |
| EXPECT_EQ(3, map.GetInternalSize()); // +1 |
| |
| map.GetFrameDataOnIO(7, 2, CreateCallback(7, 2, "not queued")); |
| EXPECT_EQ(3, map.GetInternalCallbackCount()); // -1 (first callback ran). |
| EXPECT_EQ(3, map.GetInternalSize()); // No change. |
| ASSERT_EQ(2U, results().size()); // +2 (both callbacks ran). |
| EXPECT_EQ("queued", results()[0]); |
| EXPECT_EQ("not queued", results()[1]); |
| ClearResults(); |
| } |
| |
| // A call identical to the very first call. |
| map.GetFrameDataOnIO(1, 2, CreateCallback(1, 2, "same as first")); |
| EXPECT_EQ(4, map.GetInternalCallbackCount()); |
| EXPECT_EQ(3, map.GetInternalSize()); |
| |
| // Trigger the queued callbacks. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(0, map.GetInternalCallbackCount()); // -4 (no queued callbacks). |
| |
| EXPECT_EQ(4, map.GetInternalSize()); // +1 (1 new cached frame ID). |
| ASSERT_EQ(4U, results().size()); // +4 (callbacks ran). |
| |
| // PostTasks are processed in order, so the very first callbacks should be |
| // processed. As soon as the first callback is available, all of its callbacks |
| // should be run (no deferrals!). |
| EXPECT_EQ("first", results()[0]); |
| EXPECT_EQ("first again", results()[1]); |
| EXPECT_EQ("same as first", results()[2]); |
| // This was queued after "first again", but has a different frame ID, so it |
| // is received after "same as first". |
| EXPECT_EQ("something else", results()[3]); |
| ClearResults(); |
| |
| // Request the frame ID for input that was already looked up. Should complete |
| // synchronously. |
| map.GetFrameDataOnIO(1, 2, CreateCallback(1, 2, "first and cached")); |
| EXPECT_EQ(0, map.GetInternalCallbackCount()); // No change. |
| EXPECT_EQ(4, map.GetInternalSize()); // No change. |
| ASSERT_EQ(1U, results().size()); // +1 (synchronous callback). |
| EXPECT_EQ("first and cached", results()[0]); |
| ClearResults(); |
| |
| // Trigger frame removal and look up frame ID. The frame ID should no longer |
| // be available. and GetFrameDataOnIO() should require a thread hop. |
| map.RemoveInternalFrameData(1, 2); |
| EXPECT_EQ(3, map.GetInternalSize()); // -1 |
| map.GetFrameDataOnIO(1, 2, CreateCallback(1, 2, "first was removed")); |
| EXPECT_EQ(1, map.GetInternalCallbackCount()); // +1 |
| ASSERT_EQ(0U, results().size()); // No change (queued callback). |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(0, map.GetInternalCallbackCount()); // -1 (callback not in queue). |
| EXPECT_EQ(4, map.GetInternalSize()); // +1 (cached frame ID). |
| ASSERT_EQ(1U, results().size()); // +1 (callback ran). |
| EXPECT_EQ("first was removed", results()[0]); |
| } |
| |
| TEST_F(ExtensionApiFrameIdMapTest, GetCachedFrameDataOnIO) { |
| TestExtensionApiFrameIdMap map; |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| const int kRenderProcessId = 1; |
| const int kFrameRoutingId = 2; |
| |
| // Getting cached data on the IO thread should fail if there is no cached |
| // data for the entry... |
| ExtensionApiFrameIdMap::FrameData data; |
| EXPECT_FALSE( |
| map.GetCachedFrameDataOnIO(kRenderProcessId, kFrameRoutingId, &data)); |
| // ... should not queue any callbacks... |
| EXPECT_EQ(0, map.GetInternalCallbackCount()); |
| base::RunLoop().RunUntilIdle(); |
| // ... and should not add any entries to the map. |
| EXPECT_EQ(0, map.GetInternalSize()); |
| |
| // Getting cached data should succeed if there is a cached entry. |
| map.SetInternalFrameData(kRenderProcessId, kFrameRoutingId); |
| EXPECT_EQ(1, map.GetInternalSize()); |
| EXPECT_TRUE( |
| map.GetCachedFrameDataOnIO(kRenderProcessId, kFrameRoutingId, &data)); |
| EXPECT_EQ(0, map.GetInternalCallbackCount()); |
| EXPECT_EQ(ToTestFrameId(kRenderProcessId, kFrameRoutingId), data.frame_id); |
| EXPECT_EQ(ToTestParentFrameId(kRenderProcessId, kFrameRoutingId), |
| data.parent_frame_id); |
| EXPECT_EQ(ToTestTabId(kRenderProcessId, kFrameRoutingId), data.tab_id); |
| EXPECT_EQ(ToTestWindowId(kRenderProcessId, kFrameRoutingId), data.window_id); |
| EXPECT_EQ(ToTestLastCommittedMainFrameURL(kRenderProcessId, kFrameRoutingId), |
| data.last_committed_main_frame_url); |
| } |
| |
| } // namespace extensions |