Limit image decoded size on low end Android devices

webkit/child/webkitplatformsupport_impl.cc

 // Copyright (c) 2012 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 "webkit/child/webkitplatformsupport_impl.h"
 
 #include <math.h>
 
 #include <vector>
 
@@ skipping 33 matching lines @@
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 #include "ui/base/layout.h"
 #include "webkit/child/webkit_child_helpers.h"
 #include "webkit/child/websocketstreamhandle_impl.h"
 #include "webkit/child/weburlloader_impl.h"
 #include "webkit/common/user_agent/user_agent.h"
 #include "webkit/glue/webkit_glue.h"
 
+#if defined(OS_ANDROID)
+#include "base/android/sys_utils.h"
+#endif
+
 using WebKit::WebAudioBus;
 using WebKit::WebCookie;
 using WebKit::WebData;
 using WebKit::WebLocalizedString;
 using WebKit::WebPluginListBuilder;
 using WebKit::WebString;
 using WebKit::WebSocketStreamHandle;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
@@ skipping 808 matching lines @@
 bool WebKitPlatformSupportImpl::processMemorySizesInBytes(
     size_t* private_bytes,
     size_t* shared_bytes) {
   return CurrentProcessMetrics()->GetMemoryBytes(private_bytes, shared_bytes);
 }
 
 bool WebKitPlatformSupportImpl::memoryAllocatorWasteInBytes(size_t* size) {
   return base::allocator::GetAllocatorWasteSize(size);
 }
 
+size_t WebKitPlatformSupportImpl::maxImageDecodedBytes() {
+#if defined(OS_ANDROID)
+  // Limit image decoded size to 3M pixels on low end devices.
+  if (base::android::SysUtils::IsLowEndDevice())
+    return 3 * 1000 * 1000 * 4;  // 4 is maximum number of bytes per pixel.
+#endif
+  return 0;  // Unlimited.

[tony, 2013/09/20 22:27:04]

Having 0 mean unlimited is a bit weird.  Why not return
numeric_limits<size_t>::max()?

It seems inconsistent that a phone with <= 512mb has a limit, but if a laptop or
desktop has <= 512mb, we continue to decode the image.  Is it worth trying to
scale the image decode size based on memory and/or swap space?

Out of curiosity, are there many phones that can run Chrome (i.e., have Android
OS 4.x) and have <= 512mb of memory?

[Xianzhu, 2013/09/20 23:13:47]

Done.
For now we want to focus on the bug (which is Android-only) and limit this CL to
Android only which will ease the merge process.

+}
+
 void WebKitPlatformSupportImpl::SuspendSharedTimer() {
   ++shared_timer_suspended_;
 }
 
 void WebKitPlatformSupportImpl::ResumeSharedTimer() {
   // The shared timer may have fired or been adjusted while we were suspended.
   if (--shared_timer_suspended_ == 0 &&
       (!shared_timer_.IsRunning() ||
        shared_timer_fire_time_was_set_while_suspended_)) {
     shared_timer_fire_time_was_set_while_suspended_ = false;
     setSharedTimerFireInterval(
         shared_timer_fire_time_ - monotonicallyIncreasingTime());
   }
 }
 
 }  // namespace webkit_glue