Implement device-ram client hints header

content/child/blink_platform_impl.cc

 // Copyright 2014 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 "content/child/blink_platform_impl.h"
 
 #include <math.h>
 
 #include <memory>
 #include <vector>
@@ skipping 342 matching lines @@
 // constructing the platform.
 BlinkPlatformImpl::BlinkPlatformImpl()
     : BlinkPlatformImpl(base::ThreadTaskRunnerHandle::IsSet()
                             ? base::ThreadTaskRunnerHandle::Get()
                             : nullptr) {
 }
 
 BlinkPlatformImpl::BlinkPlatformImpl(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : main_thread_task_runner_(main_thread_task_runner),
-      compositor_thread_(nullptr) {
+      compositor_thread_(nullptr),
+      physical_memory_mb_(
+          static_cast<size_t>(base::SysInfo::AmountOfPhysicalMemoryMB())) {

[kinuko, 2017/05/25 05:31:27]

Hum, this doesn't seem we need public platform plumbing actually?

   InternalInit();
 }
 
 void BlinkPlatformImpl::InternalInit() {
   // ChildThread may not exist in some tests.
   if (ChildThreadImpl::current()) {
     thread_safe_sender_ = ChildThreadImpl::current()->thread_safe_sender();
     notification_dispatcher_ =
         ChildThreadImpl::current()->notification_dispatcher();
   }
@@ skipping 396 matching lines @@
 bool BlinkPlatformImpl::DatabaseSetFileSize(
     const blink::WebString& vfs_file_name,
     long long size) {
   return false;
 }
 
 size_t BlinkPlatformImpl::ActualMemoryUsageMB() {
   return GetMemoryUsageKB() >> 10;
 }
 
+size_t BlinkPlatformImpl::AmountOfPhysicalMemoryMB() {
+  return physical_memory_mb_;
+}
+
+void BlinkPlatformImpl::SetDevicePhysicalMemoryMBForTesting(
+    int64_t physical_memory_mb) {
+  physical_memory_mb_ = static_cast<size_t>(physical_memory_mb);
+}
+
 size_t BlinkPlatformImpl::NumberOfProcessors() {
   return static_cast<size_t>(base::SysInfo::NumberOfProcessors());
 }
 
 size_t BlinkPlatformImpl::MaxDecodedImageBytes() {
 #if defined(OS_ANDROID)
   if (base::SysInfo::IsLowEndDevice()) {
     // Limit image decoded size to 3M pixels on low end devices.
     // 4 is maximum number of bytes per pixel.
     return 3 * 1024 * 1024 * 4;
@@ skipping 61 matching lines @@
 
 std::unique_ptr<blink::WebFeaturePolicy>
 BlinkPlatformImpl::DuplicateFeaturePolicyWithOrigin(
     const blink::WebFeaturePolicy& policy,
     const blink::WebSecurityOrigin& new_origin) {
   return FeaturePolicy::CreateFromPolicyWithOrigin(
       static_cast<const FeaturePolicy&>(policy), url::Origin(new_origin));
 }
 
 }  // namespace content