OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "platform/scheduler/base/task_queue_manager.h" | 5 #include "platform/scheduler/base/task_queue_manager.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 1745 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1756 queue0->PostTask( | 1756 queue0->PostTask( |
1757 FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask, | 1757 FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask, |
1758 message_loop_.get(), manager_.get(), &task_sources, | 1758 message_loop_.get(), manager_.get(), &task_sources, |
1759 &tasks_to_post_from_nested_loop)); | 1759 &tasks_to_post_from_nested_loop)); |
1760 | 1760 |
1761 base::RunLoop().RunUntilIdle(); | 1761 base::RunLoop().RunUntilIdle(); |
1762 EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0)); | 1762 EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0)); |
1763 EXPECT_EQ(nullptr, manager_->currently_executing_task_queue()); | 1763 EXPECT_EQ(nullptr, manager_->currently_executing_task_queue()); |
1764 } | 1764 } |
1765 | 1765 |
1766 TEST_F(TaskQueueManagerTest, NullHandleConvertsToFalse) { | |
1767 EXPECT_FALSE(TaskQueue::TaskHandle()); | |
1768 } | |
1769 | |
1770 TEST_F(TaskQueueManagerTest, PostCancellableTask) { | |
1771 Initialize(1u); | |
1772 | |
1773 std::vector<EnqueueOrder> run_order; | |
1774 runners_[0]->PostCancellableDelayedTask( | |
1775 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1776 | |
1777 test_task_runner_->RunUntilIdle(); | |
1778 EXPECT_THAT(run_order, ElementsAre(1)); | |
1779 } | |
1780 | |
1781 TEST_F(TaskQueueManagerTest, PostCancellableTask_AndCancel_OnIncomingQueue) { | |
1782 Initialize(1u); | |
1783 | |
1784 std::vector<EnqueueOrder> run_order; | |
1785 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1786 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1787 EXPECT_TRUE(handle); | |
1788 | |
1789 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1790 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1791 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1792 test_task_runner_->RunUntilIdle(); | |
1793 EXPECT_TRUE(run_order.empty()); | |
1794 } | |
1795 | |
1796 TEST_F(TaskQueueManagerTest, PostThreeTasks_AndCancelOne_OnIncomingQueue) { | |
1797 Initialize(1u); | |
1798 | |
1799 std::vector<EnqueueOrder> run_order; | |
1800 runners_[0]->PostCancellableDelayedTask( | |
1801 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1802 | |
1803 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1804 FROM_HERE, base::Bind(&TestTask, 2, &run_order), base::TimeDelta()); | |
1805 EXPECT_TRUE(handle); | |
1806 | |
1807 runners_[0]->PostCancellableDelayedTask( | |
1808 FROM_HERE, base::Bind(&TestTask, 3, &run_order), base::TimeDelta()); | |
1809 | |
1810 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1811 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1812 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1813 test_task_runner_->RunUntilIdle(); | |
1814 EXPECT_THAT(run_order, ElementsAre(1, 3)); | |
1815 } | |
1816 | |
1817 TEST_F(TaskQueueManagerTest, PostCancellableTask_AndCancel_OnWorkQueue) { | |
1818 Initialize(1u); | |
1819 | |
1820 std::vector<EnqueueOrder> run_order; | |
1821 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1822 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1823 EXPECT_TRUE(handle); | |
1824 | |
1825 // Force the task onto the work queue. | |
1826 UpdateWorkQueues(LazyNow(now_src_.get())); | |
1827 | |
1828 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1829 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1830 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1831 test_task_runner_->RunUntilIdle(); | |
1832 EXPECT_TRUE(run_order.empty()); | |
1833 } | |
1834 | |
1835 TEST_F(TaskQueueManagerTest, PostThreeTasks_AndCancelOne_OnWorkQueue) { | |
1836 Initialize(1u); | |
1837 | |
1838 std::vector<EnqueueOrder> run_order; | |
1839 runners_[0]->PostCancellableDelayedTask( | |
1840 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1841 | |
1842 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1843 FROM_HERE, base::Bind(&TestTask, 2, &run_order), base::TimeDelta()); | |
1844 EXPECT_TRUE(handle); | |
1845 | |
1846 runners_[0]->PostCancellableDelayedTask( | |
1847 FROM_HERE, base::Bind(&TestTask, 3, &run_order), base::TimeDelta()); | |
1848 | |
1849 // Force the tasks onto the work queue. | |
1850 UpdateWorkQueues(LazyNow(now_src_.get())); | |
1851 | |
1852 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1853 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1854 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1855 test_task_runner_->RunUntilIdle(); | |
1856 EXPECT_THAT(run_order, ElementsAre(1, 3)); | |
1857 } | |
1858 | |
1859 TEST_F(TaskQueueManagerTest, PostThreeTasksOnDifferentQueues_AndCancelOne) { | |
1860 Initialize(3u); | |
1861 | |
1862 std::vector<EnqueueOrder> run_order; | |
1863 runners_[0]->PostCancellableDelayedTask( | |
1864 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1865 | |
1866 TaskQueue::TaskHandle handle = runners_[1]->PostCancellableDelayedTask( | |
1867 FROM_HERE, base::Bind(&TestTask, 2, &run_order), base::TimeDelta()); | |
1868 EXPECT_TRUE(handle); | |
1869 | |
1870 runners_[2]->PostCancellableDelayedTask( | |
1871 FROM_HERE, base::Bind(&TestTask, 3, &run_order), base::TimeDelta()); | |
1872 | |
1873 // Force the tasks onto the work queues. | |
1874 UpdateWorkQueues(LazyNow(now_src_.get())); | |
1875 | |
1876 EXPECT_TRUE(runners_[1]->IsTaskPending(handle)); | |
1877 EXPECT_TRUE(runners_[1]->CancelTask(handle)); | |
1878 EXPECT_FALSE(runners_[1]->IsTaskPending(handle)); | |
1879 test_task_runner_->RunUntilIdle(); | |
1880 EXPECT_THAT(run_order, ElementsAre(1, 3)); | |
1881 } | |
1882 | |
1883 TEST_F(TaskQueueManagerTest, TryToCancelTaskAfterItsRun) { | |
1884 Initialize(1u); | |
1885 | |
1886 std::vector<EnqueueOrder> run_order; | |
1887 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1888 FROM_HERE, base::Bind(&TestTask, 1, &run_order), base::TimeDelta()); | |
1889 EXPECT_TRUE(handle); | |
1890 | |
1891 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1892 test_task_runner_->RunUntilIdle(); | |
1893 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1894 EXPECT_THAT(run_order, ElementsAre(1)); | |
1895 | |
1896 EXPECT_FALSE(runners_[0]->CancelTask(handle)); | |
1897 } | |
1898 | |
1899 TEST_F(TaskQueueManagerTest, PostCancellableDelayedTask) { | |
1900 Initialize(1u); | |
1901 | |
1902 std::vector<EnqueueOrder> run_order; | |
1903 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
1904 base::Bind(&TestTask, 1, &run_order), | |
1905 base::TimeDelta::FromMilliseconds(1)); | |
1906 | |
1907 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | |
1908 EXPECT_THAT(run_order, ElementsAre(1)); | |
1909 } | |
1910 | |
1911 TEST_F(TaskQueueManagerTest, | |
1912 PostCancellableDelayedTask_AndCancel_OnIncomingQueue) { | |
1913 Initialize(1u); | |
1914 | |
1915 std::vector<EnqueueOrder> run_order; | |
1916 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1917 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
1918 base::TimeDelta::FromMilliseconds(1)); | |
1919 EXPECT_TRUE(handle); | |
1920 | |
1921 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1922 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1923 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1924 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | |
1925 EXPECT_TRUE(run_order.empty()); | |
1926 } | |
1927 | |
1928 TEST_F(TaskQueueManagerTest, | |
1929 PostThreeDelayedTasks_AndCancelOne_OnIncomingQueue) { | |
1930 Initialize(1u); | |
1931 | |
1932 std::vector<EnqueueOrder> run_order; | |
1933 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
1934 base::Bind(&TestTask, 1, &run_order), | |
1935 base::TimeDelta::FromMilliseconds(3)); | |
1936 | |
1937 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1938 FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
1939 base::TimeDelta::FromMilliseconds(2)); | |
1940 EXPECT_TRUE(handle); | |
1941 | |
1942 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
1943 base::Bind(&TestTask, 3, &run_order), | |
1944 base::TimeDelta::FromMilliseconds(1)); | |
1945 | |
1946 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
1947 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1948 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
1949 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(3)); | |
1950 EXPECT_THAT(run_order, ElementsAre(3, 1)); | |
1951 } | |
1952 | |
1953 TEST_F(TaskQueueManagerTest, DelayedTaskCancellationRemovesWakeup) { | |
1954 Initialize(1u); | |
1955 | |
1956 std::vector<EnqueueOrder> run_order; | |
1957 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1958 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
1959 base::TimeDelta::FromMilliseconds(1)); | |
1960 EXPECT_TRUE(handle); | |
1961 | |
1962 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1963 | |
1964 base::TimeTicks dummy; | |
1965 EXPECT_FALSE(manager_->real_time_domain()->NextScheduledRunTime(&dummy)); | |
1966 } | |
1967 | |
1968 TEST_F(TaskQueueManagerTest, DelayedTaskCancellationDoesntRemoveWakeupCaseA) { | |
1969 Initialize(1u); | |
1970 | |
1971 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
1972 | |
1973 std::vector<EnqueueOrder> run_order; | |
1974 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
1975 base::Bind(&TestTask, 1, &run_order), | |
1976 base::TimeDelta::FromMilliseconds(1)); | |
1977 | |
1978 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1979 FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
1980 base::TimeDelta::FromMilliseconds(1)); | |
1981 EXPECT_TRUE(handle); | |
1982 | |
1983 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
1984 | |
1985 base::TimeTicks run_time; | |
1986 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | |
1987 EXPECT_EQ(run_time, start_time + base::TimeDelta::FromMilliseconds(1)); | |
1988 } | |
1989 | |
1990 TEST_F(TaskQueueManagerTest, DelayedTaskCancellationDoesntRemoveWakeupCaseB) { | |
1991 Initialize(1u); | |
1992 | |
1993 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
1994 | |
1995 std::vector<EnqueueOrder> run_order; | |
1996 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
1997 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
1998 base::TimeDelta::FromMilliseconds(1)); | |
1999 EXPECT_TRUE(handle); | |
2000 | |
2001 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
2002 base::Bind(&TestTask, 2, &run_order), | |
2003 base::TimeDelta::FromMilliseconds(1)); | |
2004 | |
2005 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
2006 | |
2007 base::TimeTicks run_time; | |
2008 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | |
2009 EXPECT_EQ(run_time, start_time + base::TimeDelta::FromMilliseconds(1)); | |
2010 } | |
2011 | |
2012 TEST_F(TaskQueueManagerTest, DelayedTaskCancellationRemovesMiddleWakeup) { | |
2013 Initialize(1u); | |
2014 | |
2015 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
2016 | |
2017 std::vector<EnqueueOrder> run_order; | |
2018 // Note the TimeDomain doesn't attempt to clear the next wakeup. | |
2019 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
2020 base::Bind(&TestTask, 1, &run_order), | |
2021 base::TimeDelta::FromMilliseconds(1)); | |
2022 | |
2023 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
2024 FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
2025 base::TimeDelta::FromMilliseconds(2)); | |
2026 EXPECT_TRUE(handle); | |
2027 | |
2028 runners_[0]->PostCancellableDelayedTask( | |
2029 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
2030 base::TimeDelta::FromMilliseconds(10)); | |
2031 | |
2032 // But it should clear subsequent ones. | |
2033 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
2034 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | |
2035 | |
2036 base::TimeTicks run_time; | |
2037 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | |
2038 EXPECT_EQ(run_time, start_time + base::TimeDelta::FromMilliseconds(10)); | |
2039 } | |
2040 | |
2041 TEST_F(TaskQueueManagerTest, PostDelayedCancellableTask_AndCancel_OnWorkQueue) { | |
2042 Initialize(1u); | |
2043 | |
2044 std::vector<EnqueueOrder> run_order; | |
2045 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
2046 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
2047 base::TimeDelta::FromMilliseconds(1)); | |
2048 EXPECT_TRUE(handle); | |
2049 | |
2050 // Force the task onto the work queue. | |
2051 now_src_->Advance(base::TimeDelta::FromMilliseconds(10)); | |
2052 UpdateWorkQueues(LazyNow(now_src_.get())); | |
2053 | |
2054 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
2055 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
2056 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
2057 test_task_runner_->RunUntilIdle(); | |
2058 EXPECT_TRUE(run_order.empty()); | |
2059 } | |
2060 | |
2061 TEST_F(TaskQueueManagerTest, PostThreeDelayedTasks_AndCancelOne_OnWorkQueue) { | |
2062 Initialize(1u); | |
2063 | |
2064 std::vector<EnqueueOrder> run_order; | |
2065 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
2066 base::Bind(&TestTask, 1, &run_order), | |
2067 base::TimeDelta::FromMilliseconds(3)); | |
2068 | |
2069 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
2070 FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
2071 base::TimeDelta::FromMilliseconds(2)); | |
2072 EXPECT_TRUE(handle); | |
2073 | |
2074 runners_[0]->PostCancellableDelayedTask(FROM_HERE, | |
2075 base::Bind(&TestTask, 3, &run_order), | |
2076 base::TimeDelta::FromMilliseconds(1)); | |
2077 | |
2078 // Force the tasks onto the work queue. | |
2079 now_src_->Advance(base::TimeDelta::FromMilliseconds(10)); | |
2080 UpdateWorkQueues(LazyNow(now_src_.get())); | |
2081 | |
2082 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
2083 EXPECT_TRUE(runners_[0]->CancelTask(handle)); | |
2084 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
2085 test_task_runner_->RunUntilIdle(); | |
2086 EXPECT_THAT(run_order, ElementsAre(3, 1)); | |
2087 } | |
2088 | |
2089 TEST_F(TaskQueueManagerTest, BulkPostingDelayedTasks_AndCancelOnWorkQueue) { | |
2090 Initialize(1u); | |
2091 | |
2092 const size_t num_iterations = 1000; | |
2093 std::vector<EnqueueOrder> run_order; | |
2094 std::vector<TaskQueue::TaskHandle> handles(num_iterations); | |
2095 | |
2096 for (size_t i = 0; i < num_iterations; i++) { | |
2097 handles[i] = runners_[0]->PostCancellableDelayedTask( | |
2098 FROM_HERE, base::Bind(&TestTask, i, &run_order), | |
2099 base::TimeDelta::FromMilliseconds(1000)); | |
2100 | |
2101 if (i % 4 == 0) | |
2102 now_src_->Advance(base::TimeDelta::FromMilliseconds(1)); | |
2103 } | |
2104 | |
2105 // Force the tasks onto the work queue. | |
2106 now_src_->Advance(base::TimeDelta::FromMilliseconds(2000)); | |
2107 UpdateWorkQueues(LazyNow(now_src_.get())); | |
2108 | |
2109 // Cancel three timers. | |
2110 EXPECT_TRUE(runners_[0]->CancelTask(handles[123])); | |
2111 EXPECT_TRUE(runners_[0]->CancelTask(handles[456])); | |
2112 EXPECT_TRUE(runners_[0]->CancelTask(handles[789])); | |
2113 | |
2114 test_task_runner_->RunUntilIdle(); | |
2115 | |
2116 // Make sure all tasks bar the canceled ones ran. | |
2117 EXPECT_EQ(num_iterations - 3, run_order.size()); | |
2118 EXPECT_THAT(run_order, Not(Contains(123))); | |
2119 EXPECT_THAT(run_order, Not(Contains(456))); | |
2120 EXPECT_THAT(run_order, Not(Contains(789))); | |
2121 } | |
2122 | |
2123 TEST_F(TaskQueueManagerTest, TryToCancelDelayedTaskAfterItsRun) { | |
2124 Initialize(1u); | |
2125 | |
2126 std::vector<EnqueueOrder> run_order; | |
2127 TaskQueue::TaskHandle handle = runners_[0]->PostCancellableDelayedTask( | |
2128 FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
2129 base::TimeDelta::FromMilliseconds(1)); | |
2130 EXPECT_TRUE(handle); | |
2131 | |
2132 EXPECT_TRUE(runners_[0]->IsTaskPending(handle)); | |
2133 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(2)); | |
2134 EXPECT_FALSE(runners_[0]->IsTaskPending(handle)); | |
2135 EXPECT_THAT(run_order, ElementsAre(1)); | |
2136 | |
2137 EXPECT_FALSE(runners_[0]->CancelTask(handle)); | |
2138 } | |
2139 | |
2140 void OnTraceDataCollected(base::Closure quit_closure, | 1766 void OnTraceDataCollected(base::Closure quit_closure, |
2141 base::trace_event::TraceResultBuffer* buffer, | 1767 base::trace_event::TraceResultBuffer* buffer, |
2142 const scoped_refptr<base::RefCountedString>& json, | 1768 const scoped_refptr<base::RefCountedString>& json, |
2143 bool has_more_events) { | 1769 bool has_more_events) { |
2144 buffer->AddFragment(json->data()); | 1770 buffer->AddFragment(json->data()); |
2145 if (!has_more_events) | 1771 if (!has_more_events) |
2146 quit_closure.Run(); | 1772 quit_closure.Run(); |
2147 } | 1773 } |
2148 | 1774 |
2149 class TaskQueueManagerTestWithTracing : public TaskQueueManagerTest { | 1775 class TaskQueueManagerTestWithTracing : public TaskQueueManagerTest { |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2202 trace_analyzer::TraceEventVector events; | 1828 trace_analyzer::TraceEventVector events; |
2203 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || | 1829 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || |
2204 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); | 1830 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); |
2205 analyzer->FindEvents(q, &events); | 1831 analyzer->FindEvents(q, &events); |
2206 | 1832 |
2207 EXPECT_EQ(2u, events.size()); | 1833 EXPECT_EQ(2u, events.size()); |
2208 } | 1834 } |
2209 | 1835 |
2210 } // namespace scheduler | 1836 } // namespace scheduler |
2211 } // namespace blink | 1837 } // namespace blink |
OLD | NEW |