Revert "Revert 254514 "Revert 254507 "Reland "Move WebKitPlatformSupport...""

webkit/child/webkitplatformsupport_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 "webkit/child/webkitplatformsupport_impl.h"
 
 #include <math.h>
 
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/platform_file.h"
 #include "base/process/process_metrics.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
-#include "content/child/web_socket_stream_handle_impl.h"
-#include "content/child/web_url_loader_impl.h"
 #include "grit/blink_resources.h"
 #include "grit/webkit_resources.h"
 #include "grit/webkit_strings.h"
 #include "net/base/data_url.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebString.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"
 
 #if defined(OS_ANDROID)
 #include "base/android/sys_utils.h"
 #endif
 
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 #endif
 
@@ skipping 48 matching lines @@
 
   // How long the cached value should remain valid.
   base::TimeDelta cache_valid_time_;
 
   // The last time the cached value was updated.
   base::Time last_updated_time_;
 
   base::Lock lock_;
 };
 
-}  // namespace
+}  // anonymous namespace
 
-namespace content {
+namespace webkit_glue {
 
 static int ToMessageID(WebLocalizedString::Name name) {
   switch (name) {
     case WebLocalizedString::AXAMPMFieldText:
       return IDS_AX_AM_PM_FIELD_TEXT;
     case WebLocalizedString::AXButtonActionVerb:
       return IDS_AX_BUTTON_ACTION_VERB;
     case WebLocalizedString::AXCheckedCheckBoxActionVerb:
       return IDS_AX_CHECKED_CHECK_BOX_ACTION_VERB;
     case WebLocalizedString::AXDateTimeFieldEmptyValueText:
@@ skipping 215 matching lines @@
     // This "default:" line exists to avoid compile warnings about enum
     // coverage when we add a new symbol to WebLocalizedString.h in WebKit.
     // After a planned WebKit patch is landed, we need to add a case statement
     // for the added symbol here.
     default:
       break;
   }
   return -1;
 }
 
-BlinkPlatformImpl::BlinkPlatformImpl()
+WebKitPlatformSupportImpl::WebKitPlatformSupportImpl()
     : main_loop_(base::MessageLoop::current()),
       shared_timer_func_(NULL),
       shared_timer_fire_time_(0.0),
       shared_timer_fire_time_was_set_while_suspended_(false),
       shared_timer_suspended_(0) {}
 
-BlinkPlatformImpl::~BlinkPlatformImpl() {
+WebKitPlatformSupportImpl::~WebKitPlatformSupportImpl() {
 }
 
-WebURLLoader* BlinkPlatformImpl::createURLLoader() {
+WebURLLoader* WebKitPlatformSupportImpl::createURLLoader() {
   return new WebURLLoaderImpl(this);
 }
 
-WebSocketStreamHandle* BlinkPlatformImpl::createSocketStreamHandle() {
+WebSocketStreamHandle* WebKitPlatformSupportImpl::createSocketStreamHandle() {
   return new WebSocketStreamHandleImpl(this);
 }
 
-WebString BlinkPlatformImpl::userAgent(const WebURL& url) {
+WebString WebKitPlatformSupportImpl::userAgent(const WebURL& url) {
   return WebString::fromUTF8(webkit_glue::GetUserAgent(url));
 }
 
-WebData BlinkPlatformImpl::parseDataURL(
+WebData WebKitPlatformSupportImpl::parseDataURL(
     const WebURL& url,
     WebString& mimetype_out,
     WebString& charset_out) {
   std::string mime_type, char_set, data;
   if (net::DataURL::Parse(url, &mime_type, &char_set, &data)
       && net::IsSupportedMimeType(mime_type)) {
     mimetype_out = WebString::fromUTF8(mime_type);
     charset_out = WebString::fromUTF8(char_set);
     return data;
   }
   return WebData();
 }
 
-WebURLError BlinkPlatformImpl::cancelledError(
+WebURLError WebKitPlatformSupportImpl::cancelledError(
     const WebURL& unreachableURL) const {
   return WebURLLoaderImpl::CreateError(unreachableURL, false, net::ERR_ABORTED);
 }
 
-void BlinkPlatformImpl::decrementStatsCounter(const char* name) {
+void WebKitPlatformSupportImpl::decrementStatsCounter(const char* name) {
   base::StatsCounter(name).Decrement();
 }
 
-void BlinkPlatformImpl::incrementStatsCounter(const char* name) {
+void WebKitPlatformSupportImpl::incrementStatsCounter(const char* name) {
   base::StatsCounter(name).Increment();
 }
 
-void BlinkPlatformImpl::histogramCustomCounts(
+void WebKitPlatformSupportImpl::histogramCustomCounts(
     const char* name, int sample, int min, int max, int bucket_count) {
   // Copied from histogram macro, but without the static variable caching
   // the histogram because name is dynamic.
   base::HistogramBase* counter =
       base::Histogram::FactoryGet(name, min, max, bucket_count,
           base::HistogramBase::kUmaTargetedHistogramFlag);
   DCHECK_EQ(name, counter->histogram_name());
   counter->Add(sample);
 }
 
-void BlinkPlatformImpl::histogramEnumeration(
+void WebKitPlatformSupportImpl::histogramEnumeration(
     const char* name, int sample, int boundary_value) {
   // Copied from histogram macro, but without the static variable caching
   // the histogram because name is dynamic.
   base::HistogramBase* counter =
       base::LinearHistogram::FactoryGet(name, 1, boundary_value,
           boundary_value + 1, base::HistogramBase::kUmaTargetedHistogramFlag);
   DCHECK_EQ(name, counter->histogram_name());
   counter->Add(sample);
 }
 
-void BlinkPlatformImpl::histogramSparse(const char* name, int sample) {
+void WebKitPlatformSupportImpl::histogramSparse(const char* name, int sample) {
   // For sparse histograms, we can use the macro, as it does not incorporate a
   // static.
   UMA_HISTOGRAM_SPARSE_SLOWLY(name, sample);
 }
 
-const unsigned char* BlinkPlatformImpl::getTraceCategoryEnabledFlag(
+const unsigned char* WebKitPlatformSupportImpl::getTraceCategoryEnabledFlag(
     const char* category_group) {
   return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);
 }
 
-long* BlinkPlatformImpl::getTraceSamplingState(
+long* WebKitPlatformSupportImpl::getTraceSamplingState(
     const unsigned thread_bucket) {
   switch (thread_bucket) {
     case 0:
       return reinterpret_cast<long*>(&TRACE_EVENT_API_THREAD_BUCKET(0));
     case 1:
       return reinterpret_cast<long*>(&TRACE_EVENT_API_THREAD_BUCKET(1));
     case 2:
       return reinterpret_cast<long*>(&TRACE_EVENT_API_THREAD_BUCKET(2));
     default:
       NOTREACHED() << "Unknown thread bucket type.";
   }
   return NULL;
 }
 
 COMPILE_ASSERT(
     sizeof(blink::Platform::TraceEventHandle) ==
         sizeof(base::debug::TraceEventHandle),
     TraceEventHandle_types_must_be_same_size);
 
-blink::Platform::TraceEventHandle BlinkPlatformImpl::addTraceEvent(
+blink::Platform::TraceEventHandle WebKitPlatformSupportImpl::addTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
     unsigned char flags) {
   base::debug::TraceEventHandle handle = TRACE_EVENT_API_ADD_TRACE_EVENT(
       phase, category_group_enabled, name, id,
       num_args, arg_names, arg_types, arg_values, NULL, flags);
   blink::Platform::TraceEventHandle result;
   memcpy(&result, &handle, sizeof(result));
   return result;
 }
 
-void BlinkPlatformImpl::updateTraceEventDuration(
+void WebKitPlatformSupportImpl::updateTraceEventDuration(
     const unsigned char* category_group_enabled,
     const char* name,
     TraceEventHandle handle) {
   base::debug::TraceEventHandle traceEventHandle;
   memcpy(&traceEventHandle, &handle, sizeof(handle));
   TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
       category_group_enabled, name, traceEventHandle);
 }
 
 namespace {
 
-WebData loadAudioSpatializationResource(BlinkPlatformImpl* platform,
+WebData loadAudioSpatializationResource(WebKitPlatformSupportImpl* platform,
                                         const char* name) {
 #ifdef IDR_AUDIO_SPATIALIZATION_COMPOSITE
   if (!strcmp(name, "Composite")) {
     base::StringPiece resource =
         platform->GetDataResource(IDR_AUDIO_SPATIALIZATION_COMPOSITE,
                                   ui::SCALE_FACTOR_NONE);
     return WebData(resource.data(), resource.size());
   }
 #endif
 
@@ skipping 151 matching lines @@
   { "visaCC", IDR_AUTOFILL_CC_VISA, ui::SCALE_FACTOR_100P },
   { "generatePassword", IDR_PASSWORD_GENERATION_ICON, ui::SCALE_FACTOR_100P },
   { "generatePasswordHover",
     IDR_PASSWORD_GENERATION_ICON_HOVER, ui::SCALE_FACTOR_100P },
   { "syntheticTouchCursor",
     IDR_SYNTHETIC_TOUCH_CURSOR, ui::SCALE_FACTOR_100P },
 };
 
 }  // namespace
 
-WebData BlinkPlatformImpl::loadResource(const char* name) {
+WebData WebKitPlatformSupportImpl::loadResource(const char* name) {
   // Some clients will call into this method with an empty |name| when they have
   // optional resources.  For example, the PopupMenuChromium code can have icons
   // for some Autofill items but not for others.
   if (!strlen(name))
     return WebData();
 
   // Check the name prefix to see if it's an audio resource.
   if (StartsWithASCII(name, "IRC_Composite", true) ||
       StartsWithASCII(name, "Composite", true))
     return loadAudioSpatializationResource(this, name);
 
   // TODO(flackr): We should use a better than linear search here, a trie would
   // be ideal.
   for (size_t i = 0; i < arraysize(kDataResources); ++i) {
     if (!strcmp(name, kDataResources[i].name)) {
       base::StringPiece resource =
           GetDataResource(kDataResources[i].id,
                           kDataResources[i].scale_factor);
       return WebData(resource.data(), resource.size());
     }
   }
 
   NOTREACHED() << "Unknown image resource " << name;
   return WebData();
 }
 
-WebString BlinkPlatformImpl::queryLocalizedString(
+WebString WebKitPlatformSupportImpl::queryLocalizedString(
     WebLocalizedString::Name name) {
   int message_id = ToMessageID(name);
   if (message_id < 0)
     return WebString();
   return GetLocalizedString(message_id);
 }
 
-WebString BlinkPlatformImpl::queryLocalizedString(
+WebString WebKitPlatformSupportImpl::queryLocalizedString(
     WebLocalizedString::Name name, int numeric_value) {
   return queryLocalizedString(name, base::IntToString16(numeric_value));
 }
 
-WebString BlinkPlatformImpl::queryLocalizedString(
+WebString WebKitPlatformSupportImpl::queryLocalizedString(
     WebLocalizedString::Name name, const WebString& value) {
   int message_id = ToMessageID(name);
   if (message_id < 0)
     return WebString();
   return ReplaceStringPlaceholders(GetLocalizedString(message_id), value, NULL);
 }
 
-WebString BlinkPlatformImpl::queryLocalizedString(
+WebString WebKitPlatformSupportImpl::queryLocalizedString(
     WebLocalizedString::Name name,
     const WebString& value1,
     const WebString& value2) {
   int message_id = ToMessageID(name);
   if (message_id < 0)
     return WebString();
   std::vector<base::string16> values;
   values.reserve(2);
   values.push_back(value1);
   values.push_back(value2);
   return ReplaceStringPlaceholders(
       GetLocalizedString(message_id), values, NULL);
 }
 
-double BlinkPlatformImpl::currentTime() {
+double WebKitPlatformSupportImpl::currentTime() {
   return base::Time::Now().ToDoubleT();
 }
 
-double BlinkPlatformImpl::monotonicallyIncreasingTime() {
+double WebKitPlatformSupportImpl::monotonicallyIncreasingTime() {
   return base::TimeTicks::Now().ToInternalValue() /
       static_cast<double>(base::Time::kMicrosecondsPerSecond);
 }
 
-void BlinkPlatformImpl::cryptographicallyRandomValues(
+void WebKitPlatformSupportImpl::cryptographicallyRandomValues(
     unsigned char* buffer, size_t length) {
   base::RandBytes(buffer, length);
 }
 
-void BlinkPlatformImpl::setSharedTimerFiredFunction(void (*func)()) {
+void WebKitPlatformSupportImpl::setSharedTimerFiredFunction(void (*func)()) {
   shared_timer_func_ = func;
 }
 
-void BlinkPlatformImpl::setSharedTimerFireInterval(
+void WebKitPlatformSupportImpl::setSharedTimerFireInterval(
     double interval_seconds) {
   shared_timer_fire_time_ = interval_seconds + monotonicallyIncreasingTime();
   if (shared_timer_suspended_) {
     shared_timer_fire_time_was_set_while_suspended_ = true;
     return;
   }
 
   // By converting between double and int64 representation, we run the risk
   // of losing precision due to rounding errors. Performing computations in
   // microseconds reduces this risk somewhat. But there still is the potential
   // of us computing a fire time for the timer that is shorter than what we
   // need.
   // As the event loop will check event deadlines prior to actually firing
   // them, there is a risk of needlessly rescheduling events and of
   // needlessly looping if sleep times are too short even by small amounts.
   // This results in measurable performance degradation unless we use ceil() to
   // always round up the sleep times.
   int64 interval = static_cast<int64>(
       ceil(interval_seconds * base::Time::kMillisecondsPerSecond)
       * base::Time::kMicrosecondsPerMillisecond);
 
   if (interval < 0)
     interval = 0;
 
   shared_timer_.Stop();
   shared_timer_.Start(FROM_HERE, base::TimeDelta::FromMicroseconds(interval),
-                      this, &BlinkPlatformImpl::DoTimeout);
+                      this, &WebKitPlatformSupportImpl::DoTimeout);
   OnStartSharedTimer(base::TimeDelta::FromMicroseconds(interval));
 }
 
-void BlinkPlatformImpl::stopSharedTimer() {
+void WebKitPlatformSupportImpl::stopSharedTimer() {
   shared_timer_.Stop();
 }
 
-void BlinkPlatformImpl::callOnMainThread(
+void WebKitPlatformSupportImpl::callOnMainThread(
     void (*func)(void*), void* context) {
   main_loop_->PostTask(FROM_HERE, base::Bind(func, context));
 }
 
-base::PlatformFile BlinkPlatformImpl::databaseOpenFile(
+base::PlatformFile WebKitPlatformSupportImpl::databaseOpenFile(
     const blink::WebString& vfs_file_name, int desired_flags) {
   return base::kInvalidPlatformFileValue;
 }
 
-int BlinkPlatformImpl::databaseDeleteFile(
+int WebKitPlatformSupportImpl::databaseDeleteFile(
     const blink::WebString& vfs_file_name, bool sync_dir) {
   return -1;
 }
 
-long BlinkPlatformImpl::databaseGetFileAttributes(
+long WebKitPlatformSupportImpl::databaseGetFileAttributes(
     const blink::WebString& vfs_file_name) {
   return 0;
 }
 
-long long BlinkPlatformImpl::databaseGetFileSize(
+long long WebKitPlatformSupportImpl::databaseGetFileSize(
     const blink::WebString& vfs_file_name) {
   return 0;
 }
 
-long long BlinkPlatformImpl::databaseGetSpaceAvailableForOrigin(
+long long WebKitPlatformSupportImpl::databaseGetSpaceAvailableForOrigin(
     const blink::WebString& origin_identifier) {
   return 0;
 }
 
-blink::WebString BlinkPlatformImpl::signedPublicKeyAndChallengeString(
+blink::WebString WebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
     const blink::WebString& challenge,
     const blink::WebURL& url) {
   return blink::WebString("");
 }
 
 static scoped_ptr<base::ProcessMetrics> CurrentProcessMetrics() {
   using base::ProcessMetrics;
 #if defined(OS_MACOSX)
   return scoped_ptr<ProcessMetrics>(
       // The default port provider is sufficient to get data for the current
       // process.
       ProcessMetrics::CreateProcessMetrics(base::GetCurrentProcessHandle(),
                                            NULL));
 #else
   return scoped_ptr<ProcessMetrics>(
       ProcessMetrics::CreateProcessMetrics(base::GetCurrentProcessHandle()));
 #endif
 }
 
 static size_t getMemoryUsageMB(bool bypass_cache) {
   size_t current_mem_usage = 0;
   MemoryUsageCache* mem_usage_cache_singleton = MemoryUsageCache::GetInstance();
   if (!bypass_cache &&
       mem_usage_cache_singleton->IsCachedValueValid(&current_mem_usage))
     return current_mem_usage;
 
-  current_mem_usage = webkit_glue::MemoryUsageKB() >> 10;
+  current_mem_usage = MemoryUsageKB() >> 10;
   mem_usage_cache_singleton->SetMemoryValue(current_mem_usage);
   return current_mem_usage;
 }
 
-size_t BlinkPlatformImpl::memoryUsageMB() {
+size_t WebKitPlatformSupportImpl::memoryUsageMB() {
   return getMemoryUsageMB(false);
 }
 
-size_t BlinkPlatformImpl::actualMemoryUsageMB() {
+size_t WebKitPlatformSupportImpl::actualMemoryUsageMB() {
   return getMemoryUsageMB(true);
 }
 
-size_t BlinkPlatformImpl::physicalMemoryMB() {
+size_t WebKitPlatformSupportImpl::physicalMemoryMB() {
   return static_cast<size_t>(base::SysInfo::AmountOfPhysicalMemoryMB());
 }
 
-size_t BlinkPlatformImpl::numberOfProcessors() {
+size_t WebKitPlatformSupportImpl::numberOfProcessors() {
   return static_cast<size_t>(base::SysInfo::NumberOfProcessors());
 }
 
-void BlinkPlatformImpl::startHeapProfiling(
+void WebKitPlatformSupportImpl::startHeapProfiling(
   const blink::WebString& prefix) {
   // FIXME(morrita): Make this built on windows.
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   HeapProfilerStart(prefix.utf8().data());
 #endif
 }
 
-void BlinkPlatformImpl::stopHeapProfiling() {
+void WebKitPlatformSupportImpl::stopHeapProfiling() {
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   HeapProfilerStop();
 #endif
 }
 
-void BlinkPlatformImpl::dumpHeapProfiling(
+void WebKitPlatformSupportImpl::dumpHeapProfiling(
   const blink::WebString& reason) {
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   HeapProfilerDump(reason.utf8().data());
 #endif
 }
 
-WebString BlinkPlatformImpl::getHeapProfile() {
+WebString WebKitPlatformSupportImpl::getHeapProfile() {
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   char* data = GetHeapProfile();
   WebString result = WebString::fromUTF8(std::string(data));
   free(data);
   return result;
 #else
   return WebString();
 #endif
 }
 
-bool BlinkPlatformImpl::processMemorySizesInBytes(
+bool WebKitPlatformSupportImpl::processMemorySizesInBytes(
     size_t* private_bytes,
     size_t* shared_bytes) {
   return CurrentProcessMetrics()->GetMemoryBytes(private_bytes, shared_bytes);
 }
 
-bool BlinkPlatformImpl::memoryAllocatorWasteInBytes(size_t* size) {
+bool WebKitPlatformSupportImpl::memoryAllocatorWasteInBytes(size_t* size) {
   return base::allocator::GetAllocatorWasteSize(size);
 }
 
-size_t BlinkPlatformImpl::maxDecodedImageBytes() {
+size_t WebKitPlatformSupportImpl::maxDecodedImageBytes() {
 #if defined(OS_ANDROID)
   if (base::android::SysUtils::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;
   }
   // For other devices, limit decoded image size based on the amount of physical
   // memory. For a device with 2GB physical memory the limit is 16M pixels.
   return base::SysInfo::AmountOfPhysicalMemory() / 32;
 #else
   return noDecodedImageByteLimit;
 #endif
 }
 
-void BlinkPlatformImpl::SuspendSharedTimer() {
+void WebKitPlatformSupportImpl::SuspendSharedTimer() {
   ++shared_timer_suspended_;
 }
 
-void BlinkPlatformImpl::ResumeSharedTimer() {
+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 content
+}  // namespace webkit_glue