OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "content/renderer/render_thread_impl.h" | 5 #include "content/renderer/render_thread_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 #include <map> | 9 #include <map> |
10 #include <utility> | 10 #include <utility> |
(...skipping 880 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
891 categorized_worker_pool_->background_worker_thread_id(), | 891 categorized_worker_pool_->background_worker_thread_id(), |
892 base::ThreadPriority::BACKGROUND); | 892 base::ThreadPriority::BACKGROUND); |
893 #endif | 893 #endif |
894 | 894 |
895 record_purge_suspend_metric_closure_.Reset(base::Bind( | 895 record_purge_suspend_metric_closure_.Reset(base::Bind( |
896 &RenderThreadImpl::RecordPurgeAndSuspendMetrics, base::Unretained(this))); | 896 &RenderThreadImpl::RecordPurgeAndSuspendMetrics, base::Unretained(this))); |
897 record_purge_suspend_growth_metric_closure_.Reset( | 897 record_purge_suspend_growth_metric_closure_.Reset( |
898 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics, | 898 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics, |
899 base::Unretained(this))); | 899 base::Unretained(this))); |
900 | 900 |
901 purge_before_suspend_timers_closure_.Reset(base::Bind( | |
902 &RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded, | |
903 base::Unretained(this))); | |
904 suspend_timers_when_backgrounded_closure_.Reset( | |
905 base::Bind(&RenderThreadImpl::SuspendTimerQueueWhenBackgrounded, | |
906 base::Unretained(this))); | |
haraken
2017/02/03 04:30:49
Can we call this just before calling PostDelayedTa
tasak
2017/02/03 05:55:26
Done.
| |
907 | |
901 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); | 908 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); |
902 | 909 |
903 // If this renderer doesn't run inside the browser process, enable | 910 // If this renderer doesn't run inside the browser process, enable |
904 // SequencedWorkerPool. Otherwise, it should already have been enabled. | 911 // SequencedWorkerPool. Otherwise, it should already have been enabled. |
905 // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler | 912 // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler |
906 // redirection experiment concludes https://crbug.com/622400. | 913 // redirection experiment concludes https://crbug.com/622400. |
907 if (!command_line.HasSwitch(switches::kSingleProcess)) | 914 if (!command_line.HasSwitch(switches::kSingleProcess)) |
908 base::SequencedWorkerPool::EnableForProcess(); | 915 base::SequencedWorkerPool::EnableForProcess(); |
909 } | 916 } |
910 | 917 |
(...skipping 285 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1196 AddFilter(devtools_agent_message_filter_.get()); | 1203 AddFilter(devtools_agent_message_filter_.get()); |
1197 | 1204 |
1198 if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) { | 1205 if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) { |
1199 ScheduleIdleHandler(kLongIdleHandlerDelayMs); | 1206 ScheduleIdleHandler(kLongIdleHandlerDelayMs); |
1200 } else { | 1207 } else { |
1201 // If we do not track widget visibility, then assume conservatively that | 1208 // If we do not track widget visibility, then assume conservatively that |
1202 // the isolate is in background. This reduces memory usage. | 1209 // the isolate is in background. This reduces memory usage. |
1203 isolate->IsolateInBackgroundNotification(); | 1210 isolate->IsolateInBackgroundNotification(); |
1204 } | 1211 } |
1205 | 1212 |
1206 renderer_scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled( | |
1207 GetContentClient() | |
1208 ->renderer() | |
1209 ->AllowTimerSuspensionWhenProcessBackgrounded()); | |
1210 | |
1211 SkGraphics::SetResourceCacheSingleAllocationByteLimit( | 1213 SkGraphics::SetResourceCacheSingleAllocationByteLimit( |
1212 kImageCacheSingleAllocationByteLimit); | 1214 kImageCacheSingleAllocationByteLimit); |
1213 | 1215 |
1214 // Hook up blink's codecs so skia can call them | 1216 // Hook up blink's codecs so skia can call them |
1215 SkGraphics::SetImageGeneratorFromEncodedFactory( | 1217 SkGraphics::SetImageGeneratorFromEncodedFactory( |
1216 blink::WebImageGenerator::create); | 1218 blink::WebImageGenerator::create); |
1217 | 1219 |
1218 if (command_line.HasSwitch(switches::kMemoryMetrics)) { | 1220 if (command_line.HasSwitch(switches::kMemoryMetrics)) { |
1219 memory_observer_.reset(new MemoryObserver()); | 1221 memory_observer_.reset(new MemoryObserver()); |
1220 message_loop()->AddTaskObserver(memory_observer_.get()); | 1222 message_loop()->AddTaskObserver(memory_observer_.get()); |
(...skipping 413 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1634 IPC_MESSAGE_UNHANDLED(handled = false) | 1636 IPC_MESSAGE_UNHANDLED(handled = false) |
1635 IPC_END_MESSAGE_MAP() | 1637 IPC_END_MESSAGE_MAP() |
1636 return handled; | 1638 return handled; |
1637 } | 1639 } |
1638 | 1640 |
1639 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) { | 1641 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) { |
1640 ChildThreadImpl::OnProcessBackgrounded(backgrounded); | 1642 ChildThreadImpl::OnProcessBackgrounded(backgrounded); |
1641 | 1643 |
1642 if (backgrounded) { | 1644 if (backgrounded) { |
1643 renderer_scheduler_->OnRendererBackgrounded(); | 1645 renderer_scheduler_->OnRendererBackgrounded(); |
1646 | |
1647 if (GetContentClient() | |
1648 ->renderer() | |
1649 ->AllowTimerSuspensionWhenProcessBackgrounded()) { | |
1650 base::TimeDelta suspend_timers_when_backgrounded_delay = | |
1651 base::TimeDelta::FromMilliseconds( | |
1652 kSuspendTimersWhenBackgroundedDelayMillis); | |
1653 GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask( | |
1654 FROM_HERE, purge_before_suspend_timers_closure_.callback(), | |
1655 suspend_timers_when_backgrounded_delay); | |
1656 } | |
1644 } else { | 1657 } else { |
1645 renderer_scheduler_->OnRendererForegrounded(); | 1658 renderer_scheduler_->OnRendererForegrounded(); |
1659 | |
1660 purge_before_suspend_timers_closure_.Cancel(); | |
1661 purge_before_suspend_timers_closure_.Reset(base::Bind( | |
1662 &RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded, | |
1663 base::Unretained(this))); | |
1664 suspend_timers_when_backgrounded_closure_.Cancel(); | |
1665 suspend_timers_when_backgrounded_closure_.Reset( | |
1666 base::Bind(&RenderThreadImpl::SuspendTimerQueueWhenBackgrounded, | |
1667 base::Unretained(this))); | |
haraken
2017/02/03 04:30:49
Ditto. Maybe can we Reset the closure just before
tasak
2017/02/03 05:55:26
Done.
| |
1668 | |
1646 // TODO(tasak): after enabling MemoryCoordinator, remove this Notify | 1669 // TODO(tasak): after enabling MemoryCoordinator, remove this Notify |
1647 // and follow MemoryCoordinator's request. | 1670 // and follow MemoryCoordinator's request. |
1648 if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) | 1671 if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) |
1649 base::MemoryCoordinatorClientRegistry::GetInstance()->Notify( | 1672 base::MemoryCoordinatorClientRegistry::GetInstance()->Notify( |
1650 base::MemoryState::NORMAL); | 1673 base::MemoryState::NORMAL); |
1651 | 1674 |
1652 record_purge_suspend_metric_closure_.Cancel(); | 1675 record_purge_suspend_metric_closure_.Cancel(); |
1653 record_purge_suspend_metric_closure_.Reset( | 1676 record_purge_suspend_metric_closure_.Reset( |
1654 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMetrics, | 1677 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMetrics, |
1655 base::Unretained(this))); | 1678 base::Unretained(this))); |
1656 record_purge_suspend_growth_metric_closure_.Cancel(); | 1679 record_purge_suspend_growth_metric_closure_.Cancel(); |
1657 record_purge_suspend_growth_metric_closure_.Reset( | 1680 record_purge_suspend_growth_metric_closure_.Reset( |
1658 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics, | 1681 base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics, |
1659 base::Unretained(this))); | 1682 base::Unretained(this))); |
1660 } | 1683 } |
1661 } | 1684 } |
1662 | 1685 |
1686 void RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded() { | |
1687 DCHECK(IsMainThread()); | |
1688 if (!RendererIsHidden()) | |
1689 return; | |
1690 // TODO(tasak): use purge method instead of notifying SUSPENDED | |
1691 // when MemoryCoordinator supports. | |
1692 base::MemoryCoordinatorClientRegistry::GetInstance()->Notify( | |
1693 base::MemoryState::SUSPENDED); | |
1694 | |
1695 // Since purging is not a synchronous task (e.g. v8 GC, oilpan GC, ...), | |
1696 // we need to wait until the task is finished. So wait 5 seconds and | |
1697 // update purge+suspend UMA histogram. | |
1698 // TODO(tasak): use MemoryCoordinator's callback to report purge+suspend | |
1699 // UMA when MemoryCoordinator is available. | |
1700 GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask( | |
1701 FROM_HERE, suspend_timers_when_backgrounded_closure_.callback(), | |
1702 base::TimeDelta::FromSeconds(5)); | |
1703 } | |
1704 | |
1705 void RenderThreadImpl::SuspendTimerQueueWhenBackgrounded() { | |
1706 DCHECK(IsMainThread()); | |
1707 if (!RendererIsHidden()) | |
1708 return; | |
1709 renderer_scheduler_->SuspendRenderer(); | |
1710 } | |
1711 | |
1663 void RenderThreadImpl::OnProcessPurgeAndSuspend() { | 1712 void RenderThreadImpl::OnProcessPurgeAndSuspend() { |
1664 ChildThreadImpl::OnProcessPurgeAndSuspend(); | 1713 ChildThreadImpl::OnProcessPurgeAndSuspend(); |
1665 if (!RendererIsHidden()) | 1714 if (!RendererIsHidden()) |
1666 return; | 1715 return; |
1667 | 1716 |
1668 // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled. | 1717 // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled. |
1669 if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) | 1718 if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) |
1670 return; | 1719 return; |
1671 | 1720 |
1672 if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) { | 1721 if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) { |
(...skipping 767 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2440 } | 2489 } |
2441 } | 2490 } |
2442 | 2491 |
2443 void RenderThreadImpl::OnRendererInterfaceRequest( | 2492 void RenderThreadImpl::OnRendererInterfaceRequest( |
2444 mojom::RendererAssociatedRequest request) { | 2493 mojom::RendererAssociatedRequest request) { |
2445 DCHECK(!renderer_binding_.is_bound()); | 2494 DCHECK(!renderer_binding_.is_bound()); |
2446 renderer_binding_.Bind(std::move(request)); | 2495 renderer_binding_.Bind(std::move(request)); |
2447 } | 2496 } |
2448 | 2497 |
2449 } // namespace content | 2498 } // namespace content |
OLD | NEW |