Rename WebKit namespace to blink (part 5)

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 37 matching lines @@
 #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;
-using WebKit::WebVector;
+using blink::WebAudioBus;
+using blink::WebCookie;
+using blink::WebData;
+using blink::WebLocalizedString;
+using blink::WebPluginListBuilder;
+using blink::WebString;
+using blink::WebSocketStreamHandle;
+using blink::WebURL;
+using blink::WebURLError;
+using blink::WebURLLoader;
+using blink::WebVector;
 
 namespace {
 
 // A simple class to cache the memory usage for a given amount of time.
 class MemoryUsageCache {
  public:
   // Retrieves the Singleton.
   static MemoryUsageCache* GetInstance() {
     return Singleton<MemoryUsageCache>::get();
   }
@@ skipping 383 matching lines @@
       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(WebKit::Platform::TraceEventHandle) ==
+    sizeof(blink::Platform::TraceEventHandle) ==
         sizeof(base::debug::TraceEventHandle),
     TraceEventHandle_types_must_be_same_size);
 
-WebKit::Platform::TraceEventHandle WebKitPlatformSupportImpl::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);
-  WebKit::Platform::TraceEventHandle result;
+  blink::Platform::TraceEventHandle result;
   memcpy(&result, &handle, sizeof(result));
   return result;
 }
 
 void WebKitPlatformSupportImpl::updateTraceEventDuration(
     TraceEventHandle handle) {
   base::debug::TraceEventHandle traceEventHandle;
   memcpy(&traceEventHandle, &handle, sizeof(handle));
   TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(traceEventHandle);
 }
@@ skipping 287 matching lines @@
 void WebKitPlatformSupportImpl::stopSharedTimer() {
   shared_timer_.Stop();
 }
 
 void WebKitPlatformSupportImpl::callOnMainThread(
     void (*func)(void*), void* context) {
   main_loop_->PostTask(FROM_HERE, base::Bind(func, context));
 }
 
 base::PlatformFile WebKitPlatformSupportImpl::databaseOpenFile(
-    const WebKit::WebString& vfs_file_name, int desired_flags) {
+    const blink::WebString& vfs_file_name, int desired_flags) {
   return base::kInvalidPlatformFileValue;
 }
 
 int WebKitPlatformSupportImpl::databaseDeleteFile(
-    const WebKit::WebString& vfs_file_name, bool sync_dir) {
+    const blink::WebString& vfs_file_name, bool sync_dir) {
   return -1;
 }
 
 long WebKitPlatformSupportImpl::databaseGetFileAttributes(
-    const WebKit::WebString& vfs_file_name) {
+    const blink::WebString& vfs_file_name) {
   return 0;
 }
 
 long long WebKitPlatformSupportImpl::databaseGetFileSize(
-    const WebKit::WebString& vfs_file_name) {
+    const blink::WebString& vfs_file_name) {
   return 0;
 }
 
 long long WebKitPlatformSupportImpl::databaseGetSpaceAvailableForOrigin(
-    const WebKit::WebString& origin_identifier) {
+    const blink::WebString& origin_identifier) {
   return 0;
 }
 
-WebKit::WebString WebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
+blink::WebString WebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
-    const WebKit::WebString& challenge,
-    const WebKit::WebURL& url) {
-  return WebKit::WebString("");
+    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));
@@ skipping 21 matching lines @@
 
 size_t WebKitPlatformSupportImpl::actualMemoryUsageMB() {
   return getMemoryUsageMB(true);
 }
 
 size_t WebKitPlatformSupportImpl::physicalMemoryMB() {
   return static_cast<size_t>(base::SysInfo::AmountOfPhysicalMemoryMB());
 }
 
 void WebKitPlatformSupportImpl::startHeapProfiling(
-  const WebKit::WebString& prefix) {
+  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 WebKitPlatformSupportImpl::stopHeapProfiling() {
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   HeapProfilerStop();
 #endif
 }
 
 void WebKitPlatformSupportImpl::dumpHeapProfiling(
-  const WebKit::WebString& reason) {
+  const blink::WebString& reason) {
 #if !defined(NO_TCMALLOC) && defined(USE_TCMALLOC) && !defined(OS_WIN)
   HeapProfilerDump(reason.utf8().data());
 #endif
 }
 
 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);
@@ skipping 37 matching lines @@
   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