DevTools: Introduce Page.getManifest remote debugging protocol method.

content/renderer/devtools/devtools_agent.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 "content/renderer/devtools/devtools_agent.h"
 
 #include <stddef.h>
 
 #include <map>
 
+#include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/frame_messages.h"
+#include "content/public/common/manifest.h"
 #include "content/renderer/devtools/devtools_client.h"
 #include "content/renderer/devtools/devtools_cpu_throttler.h"
+#include "content/renderer/manifest/manifest_manager.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_widget.h"
 #include "ipc/ipc_channel.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDevToolsAgent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 using blink::WebDevToolsAgent;
 using blink::WebDevToolsAgentClient;
 using blink::WebLocalFrame;
 using blink::WebPoint;
 using blink::WebString;
 
 using base::trace_event::TraceLog;
 
 namespace content {
 
 namespace {
 
 const size_t kMaxMessageChunkSize = IPC::Channel::kMaximumMessageSize / 4;
+const char kPageGetAppManifest[] = "Page.getAppManifest";
+
 
 class WebKitClientMessageLoopImpl
     : public WebDevToolsAgentClient::WebKitClientMessageLoop {
  public:
   WebKitClientMessageLoopImpl() : message_loop_(base::MessageLoop::current()) {}
   ~WebKitClientMessageLoopImpl() override { message_loop_ = NULL; }
   void run() override {
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_);
     message_loop_->Run();
   }
   void quitNow() override { message_loop_->QuitNow(); }
 
  private:
   base::MessageLoop* message_loop_;
 };
 
 typedef std::map<int, DevToolsAgent*> IdToAgentMap;
 base::LazyInstance<IdToAgentMap>::Leaky
     g_agent_for_routing_id = LAZY_INSTANCE_INITIALIZER;
 
 } //  namespace
 
 DevToolsAgent::DevToolsAgent(RenderFrameImpl* frame)
     : RenderFrameObserver(frame),
       is_attached_(false),
       is_devtools_client_(false),
       paused_in_mouse_move_(false),
       paused_(false),
       frame_(frame),
-      cpu_throttler_(new DevToolsCPUThrottler()) {
+      cpu_throttler_(new DevToolsCPUThrottler()),
+      weak_factory_(this) {
   g_agent_for_routing_id.Get()[routing_id()] = this;
   frame_->GetWebFrame()->setDevToolsAgentClient(this);
 }
 
 DevToolsAgent::~DevToolsAgent() {
   g_agent_for_routing_id.Get().erase(routing_id());
 }
 
 // Called on the Renderer thread.
 bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
@@ skipping 145 matching lines @@
 void DevToolsAgent::OnDetach() {
   GetWebAgent()->detach();
   is_attached_ = false;
 }
 
 void DevToolsAgent::OnDispatchOnInspectorBackend(int session_id,
                                                  int call_id,
                                                  const std::string& method,
                                                  const std::string& message) {
   TRACE_EVENT0("devtools", "DevToolsAgent::OnDispatchOnInspectorBackend");
+  if (method == kPageGetAppManifest) {
+    ManifestManager* manager = frame_->manifest_manager();
+    manager->GetManifest(
+        base::Bind(&DevToolsAgent::GotManifest,
+        weak_factory_.GetWeakPtr(), session_id, call_id));
+    return;
+  }
   GetWebAgent()->dispatchOnInspectorBackend(session_id,
                                             call_id,
                                             WebString::fromUTF8(method),
                                             WebString::fromUTF8(message));
 }
 
 void DevToolsAgent::OnInspectElement(int x, int y) {
   GetWebAgent()->inspectElementAt(WebPoint(x, y));
 }
 
@@ skipping 17 matching lines @@
 }
 
 WebDevToolsAgent* DevToolsAgent::GetWebAgent() {
   return frame_->GetWebFrame()->devToolsAgent();
 }
 
 bool DevToolsAgent::IsAttached() {
   return is_attached_;
 }
 
+void DevToolsAgent::GotManifest(int session_id,
+                                int call_id,
+                                const Manifest& manifest,
+                                const ManifestDebugInfo& debug_info) {
+  if (!is_attached_)
+    return;
+
+  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  response->SetInteger("id", call_id);
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::ListValue> errors(new base::ListValue());
+
+  bool failed = false;
+  for (const auto& error : debug_info.errors) {
+    base::DictionaryValue* error_value = new base::DictionaryValue();
+    errors->Append(error_value);
+    error_value->SetString("message", error.message);
+    error_value->SetBoolean("critical", error.critical);
+    error_value->SetInteger("line", error.line);
+    error_value->SetInteger("column", error.column);
+    if (error.critical)
+      failed = true;
+  }
+  if (!failed)
+    result->SetString("data", debug_info.raw_data);
+  result->Set("errors", errors.release());
+  response->Set("result", result.release());
+
+  std::string json_message;
+  base::JSONWriter::Write(*response, &json_message);
+  SendChunkedProtocolMessage(this, routing_id(), session_id, call_id,
+                             json_message, std::string());
+}
+
 }  // namespace content