BASELINE: Update Chromium to 49.0.2623.23

Also adds missing printing sources.

Change-Id: I3726b8f0c7d6751c9fc846096c571fadca7108cd
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>

13 files changed, 327 insertions, 75 deletions

diff --git a/chromium/content/renderer/devtools/OWNERS b/chromium/content/renderer/devtools/OWNERS
index 120ed52a028..6ec01a4af34 100644
--- a/chromium/content/renderer/devtools/OWNERS
+++ b/chromium/content/renderer/devtools/OWNERS
@@ -1 +1 @@
-yurys@chromium.org
+dgozman@chromium.org
diff --git a/chromium/content/renderer/devtools/devtools_agent.cc b/chromium/content/renderer/devtools/devtools_agent.cc
index d464b15b941..6de2625df8b 100644
--- a/chromium/content/renderer/devtools/devtools_agent.cc
+++ b/chromium/content/renderer/devtools/devtools_agent.cc
@@ -4,6 +4,8 @@
 
 #include "content/renderer/devtools/devtools_agent.h"
 
+#include <stddef.h>
+
 #include <map>
 
 #include "base/lazy_instance.h"
@@ -13,6 +15,7 @@
 #include "content/common/devtools_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/renderer/devtools/devtools_client.h"
+#include "content/renderer/devtools/devtools_cpu_throttler.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_widget.h"
 #include "ipc/ipc_channel.h"
@@ -68,7 +71,8 @@ DevToolsAgent::DevToolsAgent(RenderFrameImpl* frame)
       is_devtools_client_(false),
       paused_in_mouse_move_(false),
       paused_(false),
-      frame_(frame) {
+      frame_(frame),
+      cpu_throttler_(new DevToolsCPUThrottler()) {
   g_agent_for_routing_id.Get()[routing_id()] = this;
   frame_->GetWebFrame()->setDevToolsAgentClient(this);
 }
@@ -101,12 +105,12 @@ void DevToolsAgent::WidgetWillClose() {
   ContinueProgram();
 }
 
-void DevToolsAgent::sendProtocolMessage(
-    int call_id,
-    const blink::WebString& message,
-    const blink::WebString& state_cookie) {
-  SendChunkedProtocolMessage(
-      this, routing_id(), call_id, message.utf8(), state_cookie.utf8());
+void DevToolsAgent::sendProtocolMessage(int session_id,
+                                        int call_id,
+                                        const blink::WebString& message,
+                                        const blink::WebString& state_cookie) {
+  SendChunkedProtocolMessage(this, routing_id(), session_id, call_id,
+                             message.utf8(), state_cookie.utf8());
 }
 
 blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
@@ -131,6 +135,12 @@ void DevToolsAgent::didExitDebugLoop() {
 }
 
 void DevToolsAgent::enableTracing(const WebString& category_filter) {
+  // Tracing is already started by DevTools TracingHandler::Start for the
+  // renderer target in the browser process. It will eventually start tracing in
+  // the renderer process via IPC. But we still need a redundant
+  // TraceLog::SetEnabled call here for
+  // InspectorTracingAgent::emitMetadataEvents(), at which point, we are not
+  // sure if tracing is already started in the renderer process.
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(
       base::trace_event::TraceConfig(category_filter.utf8(), ""),
@@ -141,6 +151,10 @@ void DevToolsAgent::disableTracing() {
   TraceLog::GetInstance()->SetDisabled();
 }
 
+void DevToolsAgent::setCPUThrottlingRate(double rate) {
+  cpu_throttler_->SetThrottlingRate(rate);
+}
+
 // static
 DevToolsAgent* DevToolsAgent::FromRoutingId(int routing_id) {
   IdToAgentMap::iterator it = g_agent_for_routing_id.Get().find(routing_id);
@@ -151,18 +165,19 @@ DevToolsAgent* DevToolsAgent::FromRoutingId(int routing_id) {
 }
 
 // static
-void DevToolsAgent::SendChunkedProtocolMessage(
-    IPC::Sender* sender,
-    int routing_id,
-    int call_id,
-    const std::string& message,
-    const std::string& post_state) {
+void DevToolsAgent::SendChunkedProtocolMessage(IPC::Sender* sender,
+                                               int routing_id,
+                                               int session_id,
+                                               int call_id,
+                                               const std::string& message,
+                                               const std::string& post_state) {
   DevToolsMessageChunk chunk;
   chunk.message_size = message.size();
   chunk.is_first = true;
 
   if (message.length() < kMaxMessageChunkSize) {
     chunk.data = message;
+    chunk.session_id = session_id;
     chunk.call_id = call_id;
     chunk.post_state = post_state;
     chunk.is_last = true;
@@ -173,6 +188,7 @@ void DevToolsAgent::SendChunkedProtocolMessage(
 
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
     chunk.is_last = pos + kMaxMessageChunkSize >= message.length();
+    chunk.session_id = chunk.is_last ? session_id : 0;
     chunk.call_id = chunk.is_last ? call_id : 0;
     chunk.post_state = chunk.is_last ? post_state : std::string();
     chunk.data = message.substr(pos, kMaxMessageChunkSize);
@@ -183,19 +199,20 @@ void DevToolsAgent::SendChunkedProtocolMessage(
   }
 }
 
-void DevToolsAgent::OnAttach(const std::string& host_id) {
+void DevToolsAgent::OnAttach(const std::string& host_id, int session_id) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->attach(WebString::fromUTF8(host_id));
+    web_agent->attach(WebString::fromUTF8(host_id), session_id);
     is_attached_ = true;
   }
 }
 
 void DevToolsAgent::OnReattach(const std::string& host_id,
+                               int session_id,
                                const std::string& agent_state) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->reattach(WebString::fromUTF8(host_id),
+    web_agent->reattach(WebString::fromUTF8(host_id), session_id,
                         WebString::fromUTF8(agent_state));
     is_attached_ = true;
   }
@@ -209,20 +226,20 @@ void DevToolsAgent::OnDetach() {
   }
 }
 
-void DevToolsAgent::OnDispatchOnInspectorBackend(const std::string& message) {
+void DevToolsAgent::OnDispatchOnInspectorBackend(int session_id,
+                                                 const std::string& message) {
   TRACE_EVENT0("devtools", "DevToolsAgent::OnDispatchOnInspectorBackend");
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent)
-    web_agent->dispatchOnInspectorBackend(WebString::fromUTF8(message));
+    web_agent->dispatchOnInspectorBackend(session_id,
+                                          WebString::fromUTF8(message));
 }
 
-void DevToolsAgent::OnInspectElement(
-    const std::string& host_id, int x, int y) {
+void DevToolsAgent::OnInspectElement(int x, int y) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->attach(WebString::fromUTF8(host_id));
+    DCHECK(is_attached_);
     web_agent->inspectElementAt(WebPoint(x, y));
-    is_attached_ = true;
   }
 }
 
diff --git a/chromium/content/renderer/devtools/devtools_agent.h b/chromium/content/renderer/devtools/devtools_agent.h
index 7b1200ba98d..ca763b7cf12 100644
--- a/chromium/content/renderer/devtools/devtools_agent.h
+++ b/chromium/content/renderer/devtools/devtools_agent.h
@@ -7,6 +7,8 @@
 
 #include <string>
 
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
 #include "content/public/common/console_message_level.h"
 #include "content/public/renderer/render_frame_observer.h"
@@ -18,6 +20,7 @@ class WebDevToolsAgent;
 
 namespace content {
 
+class DevToolsCPUThrottler;
 class RenderFrameImpl;
 
 // DevToolsAgent belongs to the inspectable RenderFrameImpl and communicates
@@ -33,12 +36,12 @@ class CONTENT_EXPORT DevToolsAgent
   // Returns agent instance for its routing id.
   static DevToolsAgent* FromRoutingId(int routing_id);
 
-  static void SendChunkedProtocolMessage(
-      IPC::Sender* sender,
-      int routing_id,
-      int call_id,
-      const std::string& message,
-      const std::string& post_state);
+  static void SendChunkedProtocolMessage(IPC::Sender* sender,
+                                         int routing_id,
+                                         int session_id,
+                                         int call_id,
+                                         const std::string& message,
+                                         const std::string& post_state);
 
   blink::WebDevToolsAgent* GetWebAgent();
 
@@ -55,7 +58,8 @@ class CONTENT_EXPORT DevToolsAgent
   void WidgetWillClose() override;
 
   // WebDevToolsAgentClient implementation.
-  void sendProtocolMessage(int call_id,
+  void sendProtocolMessage(int session_id,
+                           int call_id,
                            const blink::WebString& response,
                            const blink::WebString& state) override;
   blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
@@ -66,12 +70,15 @@ class CONTENT_EXPORT DevToolsAgent
   void enableTracing(const blink::WebString& category_filter) override;
   void disableTracing() override;
 
-  void OnAttach(const std::string& host_id);
+  void setCPUThrottlingRate(double rate) override;
+
+  void OnAttach(const std::string& host_id, int session_id);
   void OnReattach(const std::string& host_id,
+                  int session_id,
                   const std::string& agent_state);
   void OnDetach();
-  void OnDispatchOnInspectorBackend(const std::string& message);
-  void OnInspectElement(const std::string& host_id, int x, int y);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
+  void OnInspectElement(int x, int y);
   void ContinueProgram();
   void OnSetupDevToolsClient(const std::string& compatibility_script);
 
@@ -80,6 +87,7 @@ class CONTENT_EXPORT DevToolsAgent
   bool paused_in_mouse_move_;
   bool paused_;
   RenderFrameImpl* frame_;
+  scoped_ptr<DevToolsCPUThrottler> cpu_throttler_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsAgent);
 };
diff --git a/chromium/content/renderer/devtools/devtools_agent_filter.cc b/chromium/content/renderer/devtools/devtools_agent_filter.cc
index e1b3af0ba1f..a5e6b8864b0 100644
--- a/chromium/content/renderer/devtools/devtools_agent_filter.cc
+++ b/chromium/content/renderer/devtools/devtools_agent_filter.cc
@@ -60,6 +60,7 @@ bool DevToolsAgentFilter::OnMessageReceived(const IPC::Message& message) {
 DevToolsAgentFilter::~DevToolsAgentFilter() {}
 
 void DevToolsAgentFilter::OnDispatchOnInspectorBackend(
+    int session_id,
     const std::string& message) {
   if (embedded_worker_routes_.find(current_routing_id_) !=
       embedded_worker_routes_.end()) {
@@ -69,29 +70,30 @@ void DevToolsAgentFilter::OnDispatchOnInspectorBackend(
   if (WebDevToolsAgent::shouldInterruptForMessage(
           WebString::fromUTF8(message))) {
     WebDevToolsAgent::interruptAndDispatch(
-        new MessageImpl(message, current_routing_id_));
+        session_id, new MessageImpl(message, current_routing_id_));
   }
 
 }
 
-void DevToolsAgentFilter::AddEmbeddedWorkerRouteOnMainThread(int32 routing_id) {
+void DevToolsAgentFilter::AddEmbeddedWorkerRouteOnMainThread(
+    int32_t routing_id) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DevToolsAgentFilter::AddEmbeddedWorkerRoute, this,
                             routing_id));
 }
 
 void DevToolsAgentFilter::RemoveEmbeddedWorkerRouteOnMainThread(
-    int32 routing_id) {
+    int32_t routing_id) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DevToolsAgentFilter::RemoveEmbeddedWorkerRoute,
                             this, routing_id));
 }
 
-void DevToolsAgentFilter::AddEmbeddedWorkerRoute(int32 routing_id) {
+void DevToolsAgentFilter::AddEmbeddedWorkerRoute(int32_t routing_id) {
   embedded_worker_routes_.insert(routing_id);
 }
 
-void DevToolsAgentFilter::RemoveEmbeddedWorkerRoute(int32 routing_id) {
+void DevToolsAgentFilter::RemoveEmbeddedWorkerRoute(int32_t routing_id) {
   embedded_worker_routes_.erase(routing_id);
 }
 
diff --git a/chromium/content/renderer/devtools/devtools_agent_filter.h b/chromium/content/renderer/devtools/devtools_agent_filter.h
index c8ba6876ec2..ce85638f9df 100644
--- a/chromium/content/renderer/devtools/devtools_agent_filter.h
+++ b/chromium/content/renderer/devtools/devtools_agent_filter.h
@@ -5,9 +5,12 @@
 #ifndef CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_AGENT_FILTER_H_
 #define CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_AGENT_FILTER_H_
 
+#include <stdint.h>
+
 #include <set>
 #include <string>
 
+#include "base/macros.h"
 #include "ipc/message_filter.h"
 
 struct DevToolsMessageData;
@@ -36,24 +39,24 @@ class DevToolsAgentFilter : public IPC::MessageFilter {
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // Called on the main thread.
-  void AddEmbeddedWorkerRouteOnMainThread(int32 routing_id);
-  void RemoveEmbeddedWorkerRouteOnMainThread(int32 routing_id);
+  void AddEmbeddedWorkerRouteOnMainThread(int32_t routing_id);
+  void RemoveEmbeddedWorkerRouteOnMainThread(int32_t routing_id);
 
  protected:
   ~DevToolsAgentFilter() override;
 
  private:
-  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
 
   // Called on IO thread
-  void AddEmbeddedWorkerRoute(int32 routing_id);
-  void RemoveEmbeddedWorkerRoute(int32 routing_id);
+  void AddEmbeddedWorkerRoute(int32_t routing_id);
+  void RemoveEmbeddedWorkerRoute(int32_t routing_id);
 
   base::MessageLoop* render_thread_loop_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   int current_routing_id_;
 
-  std::set<int32> embedded_worker_routes_;
+  std::set<int32_t> embedded_worker_routes_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsAgentFilter);
 };
diff --git a/chromium/content/renderer/devtools/devtools_client.cc b/chromium/content/renderer/devtools/devtools_client.cc
index 92dcc177345..3f961293824 100644
--- a/chromium/content/renderer/devtools/devtools_client.cc
+++ b/chromium/content/renderer/devtools/devtools_client.cc
@@ -26,12 +26,9 @@ DevToolsClient::DevToolsClient(
     RenderFrame* main_render_frame,
     const std::string& compatibility_script)
     : RenderFrameObserver(main_render_frame),
-      compatibility_script_(compatibility_script) {
-  const base::CommandLine& command_line =
-      *base::CommandLine::ForCurrentProcess();
-  web_tools_frontend_.reset(WebDevToolsFrontend::create(
-      main_render_frame->GetRenderView()->GetWebView(), this,
-      base::ASCIIToUTF16(command_line.GetSwitchValueASCII(switches::kLang))));
+      compatibility_script_(compatibility_script),
+      web_tools_frontend_(
+          WebDevToolsFrontend::create(main_render_frame->GetWebFrame(), this)) {
 }
 
 DevToolsClient::~DevToolsClient() {
@@ -42,11 +39,6 @@ void DevToolsClient::DidClearWindowObject() {
     render_frame()->ExecuteJavaScript(base::UTF8ToUTF16(compatibility_script_));
 }
 
-void DevToolsClient::sendMessageToBackend(const WebString& message)  {
-  Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(routing_id(),
-                                                       message.utf8()));
-}
-
 void DevToolsClient::sendMessageToEmbedder(const WebString& message) {
   Send(new DevToolsHostMsg_DispatchOnEmbedder(routing_id(),
                                               message.utf8()));
diff --git a/chromium/content/renderer/devtools/devtools_client.h b/chromium/content/renderer/devtools/devtools_client.h
index 205ae1a0d95..befa179f21b 100644
--- a/chromium/content/renderer/devtools/devtools_client.h
+++ b/chromium/content/renderer/devtools/devtools_client.h
@@ -5,9 +5,11 @@
 #ifndef CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_CLIENT_H_
 #define CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_CLIENT_H_
 
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "third_party/WebKit/public/web/WebDevToolsFrontendClient.h"
@@ -38,16 +40,15 @@ class CONTENT_EXPORT DevToolsClient
   void DidClearWindowObject() override;
 
   // WebDevToolsFrontendClient implementation.
-  void sendMessageToBackend(const blink::WebString&) override;
   void sendMessageToEmbedder(const blink::WebString&) override;
 
   bool isUnderTest() override;
 
   void OnDispatchOnInspectorFrontend(const std::string& message,
-                                     uint32 total_size);
+                                     uint32_t total_size);
 
-  scoped_ptr<blink::WebDevToolsFrontend> web_tools_frontend_;
   std::string compatibility_script_;
+  scoped_ptr<blink::WebDevToolsFrontend> web_tools_frontend_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsClient);
 };
diff --git a/chromium/content/renderer/devtools/devtools_cpu_throttler.cc b/chromium/content/renderer/devtools/devtools_cpu_throttler.cc
new file mode 100644
index 00000000000..f565067437f
--- /dev/null
+++ b/chromium/content/renderer/devtools/devtools_cpu_throttler.cc
@@ -0,0 +1,187 @@
+// Copyright 2015 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/renderer/devtools/devtools_cpu_throttler.h"
+
+#if defined(OS_POSIX)
+#include <signal.h>
+#define USE_SIGNALS
+#endif
+
+#include "base/atomicops.h"
+#include "base/macros.h"
+#include "base/synchronization/cancellation_flag.h"
+#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
+
+using base::subtle::Atomic32;
+using base::subtle::Acquire_Load;
+using base::subtle::Release_Store;
+
+namespace content {
+
+class CPUThrottlingThread final : public base::PlatformThread::Delegate {
+ public:
+  explicit CPUThrottlingThread(double rate);
+  ~CPUThrottlingThread() override;
+
+  void SetThrottlingRate(double rate);
+
+ private:
+  void ThreadMain() override;
+
+  void Start();
+  void Stop();
+  void Throttle();
+
+  static void SuspendThread(base::PlatformThreadHandle thread_handle);
+  static void ResumeThread(base::PlatformThreadHandle thread_handle);
+
+#ifdef USE_SIGNALS
+  void InstallSignalHandler();
+  void RestoreSignalHandler();
+  static void HandleSignal(int signal);
+
+  static bool signal_handler_installed_;
+  static struct sigaction old_signal_handler_;
+  static Atomic32 suspended_;
+#endif
+  static Atomic32 thread_exists_;
+
+  base::PlatformThreadHandle throttled_thread_handle_;
+  base::PlatformThreadHandle throttling_thread_handle_;
+  base::CancellationFlag cancellation_flag_;
+  Atomic32 throttling_rate_percent_;
+
+  DISALLOW_COPY_AND_ASSIGN(CPUThrottlingThread);
+};
+
+#ifdef USE_SIGNALS
+bool CPUThrottlingThread::signal_handler_installed_;
+struct sigaction CPUThrottlingThread::old_signal_handler_;
+Atomic32 CPUThrottlingThread::suspended_;
+#endif
+Atomic32 CPUThrottlingThread::thread_exists_;
+
+CPUThrottlingThread::CPUThrottlingThread(double rate)
+    : throttled_thread_handle_(base::PlatformThread::CurrentHandle()),
+      throttling_rate_percent_(static_cast<Atomic32>(rate * 100)) {
+  CHECK(base::subtle::NoBarrier_AtomicExchange(&thread_exists_, 1) == 0);
+  Start();
+}
+
+CPUThrottlingThread::~CPUThrottlingThread() {
+  Stop();
+  CHECK(base::subtle::NoBarrier_AtomicExchange(&thread_exists_, 0) == 1);
+}
+
+void CPUThrottlingThread::SetThrottlingRate(double rate) {
+  Release_Store(&throttling_rate_percent_, static_cast<Atomic32>(rate * 100));
+}
+
+void CPUThrottlingThread::ThreadMain() {
+  base::PlatformThread::SetName("DevToolsCPUThrottlingThread");
+  while (!cancellation_flag_.IsSet()) {
+    Throttle();
+  }
+}
+
+#ifdef USE_SIGNALS
+
+// static
+void CPUThrottlingThread::InstallSignalHandler() {
+  // There must be the only one!
+  DCHECK(!signal_handler_installed_);
+  struct sigaction sa;
+  sa.sa_handler = &HandleSignal;
+  sigemptyset(&sa.sa_mask);
+  sa.sa_flags = SA_RESTART;
+  signal_handler_installed_ =
+      (sigaction(SIGUSR2, &sa, &old_signal_handler_) == 0);
+}
+
+// static
+void CPUThrottlingThread::RestoreSignalHandler() {
+  if (!signal_handler_installed_)
+    return;
+  sigaction(SIGUSR2, &old_signal_handler_, 0);
+  signal_handler_installed_ = false;
+}
+
+// static
+void CPUThrottlingThread::HandleSignal(int signal) {
+  if (signal != SIGUSR2)
+    return;
+  while (Acquire_Load(&suspended_)) {
+  }
+}
+
+#endif  // USE_SIGNALS
+
+// static
+void CPUThrottlingThread::SuspendThread(
+    base::PlatformThreadHandle thread_handle) {
+#ifdef USE_SIGNALS
+  Release_Store(&suspended_, 1);
+  pthread_kill(thread_handle.platform_handle(), SIGUSR2);
+#endif
+}
+
+// static
+void CPUThrottlingThread::ResumeThread(
+    base::PlatformThreadHandle thread_handle) {
+#ifdef USE_SIGNALS
+  Release_Store(&suspended_, 0);
+#endif
+}
+
+void CPUThrottlingThread::Start() {
+#ifdef USE_SIGNALS
+  InstallSignalHandler();
+#endif
+  if (!base::PlatformThread::Create(0, this, &throttling_thread_handle_)) {
+    LOG(ERROR) << "Failed to create throttling thread.";
+  }
+}
+
+void CPUThrottlingThread::Stop() {
+  cancellation_flag_.Set();
+  base::PlatformThread::Join(throttling_thread_handle_);
+#ifdef USE_SIGNALS
+  RestoreSignalHandler();
+#endif
+}
+
+void CPUThrottlingThread::Throttle() {
+  const int quant_time_us = 200;
+  double rate = Acquire_Load(&throttling_rate_percent_) / 100.;
+  base::TimeDelta run_duration =
+      base::TimeDelta::FromMicroseconds(static_cast<int>(quant_time_us / rate));
+  base::TimeDelta sleep_duration =
+      base::TimeDelta::FromMicroseconds(quant_time_us) - run_duration;
+  base::PlatformThread::Sleep(run_duration);
+  SuspendThread(throttled_thread_handle_);
+  base::PlatformThread::Sleep(sleep_duration);
+  ResumeThread(throttled_thread_handle_);
+}
+
+DevToolsCPUThrottler::DevToolsCPUThrottler() {}
+
+DevToolsCPUThrottler::~DevToolsCPUThrottler() {}
+
+void DevToolsCPUThrottler::SetThrottlingRate(double rate) {
+  if (rate <= 1) {
+    if (throttling_thread_) {
+      throttling_thread_.reset();
+    }
+    return;
+  }
+  if (throttling_thread_) {
+    throttling_thread_->SetThrottlingRate(rate);
+  } else {
+    throttling_thread_.reset(new CPUThrottlingThread(rate));
+  }
+}
+
+}  // namespace content
diff --git a/chromium/content/renderer/devtools/devtools_cpu_throttler.h b/chromium/content/renderer/devtools/devtools_cpu_throttler.h
new file mode 100644
index 00000000000..78c901a5928
--- /dev/null
+++ b/chromium/content/renderer/devtools/devtools_cpu_throttler.h
@@ -0,0 +1,31 @@
+// Copyright 2015 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.
+
+#ifndef CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_CPU_THROTTLER_H_
+#define CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_CPU_THROTTLER_H_
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class CPUThrottlingThread;
+
+class CONTENT_EXPORT DevToolsCPUThrottler final {
+ public:
+  DevToolsCPUThrottler();
+  ~DevToolsCPUThrottler();
+
+  void SetThrottlingRate(double rate);
+
+ private:
+  scoped_ptr<CPUThrottlingThread> throttling_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsCPUThrottler);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_DEVTOOLS_DEVTOOLS_CPU_THROTTLER_H_
diff --git a/chromium/content/renderer/devtools/lock_free_circular_queue.h b/chromium/content/renderer/devtools/lock_free_circular_queue.h
index dfa780bb5e7..f8a48119d0a 100644
--- a/chromium/content/renderer/devtools/lock_free_circular_queue.h
+++ b/chromium/content/renderer/devtools/lock_free_circular_queue.h
@@ -5,7 +5,10 @@
 #ifndef CONTENT_RENDERER_DEVTOOLS_LOCK_FREE_CIRCULAR_QUEUE_H_
 #define CONTENT_RENDERER_DEVTOOLS_LOCK_FREE_CIRCULAR_QUEUE_H_
 
+#include <stddef.h>
+
 #include "base/atomicops.h"
+#include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 
 #define CACHELINE_ALIGNED ALIGNAS(64)
diff --git a/chromium/content/renderer/devtools/v8_sampling_profiler.cc b/chromium/content/renderer/devtools/v8_sampling_profiler.cc
index cdad93b2006..dfd21870974 100644
--- a/chromium/content/renderer/devtools/v8_sampling_profiler.cc
+++ b/chromium/content/renderer/devtools/v8_sampling_profiler.cc
@@ -4,27 +4,32 @@
 
 #include "content/renderer/devtools/v8_sampling_profiler.h"
 
-#if defined(OS_POSIX)
-#include <signal.h>
-#define USE_SIGNALS
-#endif
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
+#include <stdint.h>
+#include <string.h>
 
 #include "base/format_macros.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "build/build_config.h"
 #include "content/renderer/devtools/lock_free_circular_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "v8/include/v8.h"
 
+#if defined(OS_POSIX)
+#include <signal.h>
+#define USE_SIGNALS
+#endif
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
 using base::trace_event::ConvertableToTraceFormat;
 using base::trace_event::TraceLog;
 using base::trace_event::TracedValue;
@@ -87,7 +92,7 @@ class PlatformData : public PlatformDataCommon {
 
 std::string PtrToString(const void* value) {
   return base::StringPrintf(
-      "0x%" PRIx64, static_cast<uint64>(reinterpret_cast<intptr_t>(value)));
+      "0x%" PRIx64, static_cast<uint64_t>(reinterpret_cast<intptr_t>(value)));
 }
 
 class SampleRecord {
@@ -97,14 +102,14 @@ class SampleRecord {
 
   SampleRecord() {}
 
-  base::TraceTicks timestamp() const { return timestamp_; }
+  base::TimeTicks timestamp() const { return timestamp_; }
   void Collect(v8::Isolate* isolate,
-               base::TraceTicks timestamp,
+               base::TimeTicks timestamp,
                const v8::RegisterState& state);
   scoped_refptr<ConvertableToTraceFormat> ToTraceFormat() const;
 
  private:
-  base::TraceTicks timestamp_;
+  base::TimeTicks timestamp_;
   unsigned vm_state_ : 4;
   unsigned frames_count_ : kMaxFramesCountLog2;
   const void* frames_[kMaxFramesCount];
@@ -113,7 +118,7 @@ class SampleRecord {
 };
 
 void SampleRecord::Collect(v8::Isolate* isolate,
-                           base::TraceTicks timestamp,
+                           base::TimeTicks timestamp,
                            const v8::RegisterState& state) {
   v8::SampleInfo sample_info;
   isolate->GetStackSample(state, (void**)frames_, kMaxFramesCount,
@@ -284,7 +289,7 @@ void Sampler::Sample() {
 void Sampler::DoSample(const v8::RegisterState& state) {
   // Called in the sampled thread signal handler.
   // Because of that it is not allowed to do any memory allocation here.
-  base::TraceTicks timestamp = base::TraceTicks::Now();
+  base::TimeTicks timestamp = base::TimeTicks::Now();
   SampleRecord* record = samples_data_->StartEnqueue();
   if (!record)
     return;
@@ -298,7 +303,7 @@ void Sampler::InjectPendingEvents() {
     TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP1(
         TRACE_DISABLED_BY_DEFAULT("v8.cpu_profile"), "V8Sample",
         platform_data_.thread_id(),
-        (record->timestamp() - base::TraceTicks()).InMicroseconds(), "data",
+        (record->timestamp() - base::TimeTicks()).InMicroseconds(), "data",
         record->ToTraceFormat());
     samples_data_->Remove();
     record = samples_data_->Peek();
@@ -637,4 +642,4 @@ void V8SamplingProfiler::WaitSamplingEventForTesting() {
   waitable_event_for_testing_->Wait();
 }
 
-}  // namespace blink
+}  // namespace content
diff --git a/chromium/content/renderer/devtools/v8_sampling_profiler.h b/chromium/content/renderer/devtools/v8_sampling_profiler.h
index 2ead2f7888f..84fa97d252b 100644
--- a/chromium/content/renderer/devtools/v8_sampling_profiler.h
+++ b/chromium/content/renderer/devtools/v8_sampling_profiler.h
@@ -5,6 +5,7 @@
 #ifndef CONTENT_RENDERER_DEVTOOLS_V8_SAMPLING_PROFILER_H_
 #define CONTENT_RENDERER_DEVTOOLS_V8_SAMPLING_PROFILER_H_
 
+#include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_log.h"
diff --git a/chromium/content/renderer/devtools/v8_sampling_profiler_browsertest.cc b/chromium/content/renderer/devtools/v8_sampling_profiler_browsertest.cc
index 1703d5d74ed..9e7df0bec0f 100644
--- a/chromium/content/renderer/devtools/v8_sampling_profiler_browsertest.cc
+++ b/chromium/content/renderer/devtools/v8_sampling_profiler_browsertest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
 #include "base/trace_event/trace_buffer.h"