Hook up WebRTC logging extension API to the underlying functionality.

chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
 
 #include "base/logging.h"
+#include "base/supports_user_data.h"
+#include "chrome/browser/media/webrtc_logging_handler_host.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+
+using content::BrowserThread;
 
 namespace extensions {
 
 namespace SetMetaData = api::webrtc_logging_private::SetMetaData;
 namespace SetUploadOnRenderClose =
     api::webrtc_logging_private::SetUploadOnRenderClose;
 
 WebrtcLoggingPrivateSetMetaDataFunction::
 WebrtcLoggingPrivateSetMetaDataFunction() {}
 
 WebrtcLoggingPrivateSetMetaDataFunction::
 ~WebrtcLoggingPrivateSetMetaDataFunction() {}
 
 bool WebrtcLoggingPrivateSetMetaDataFunction::RunImpl() {
   scoped_ptr<SetMetaData::Params> params(SetMetaData::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  std::map<std::string, std::string> meta_data;
+  std::vector<linked_ptr<api::webrtc_logging_private::MetaDataEntry> >::iterator

[no longer working on chromium, 2013/10/01 08:41:42]

Put it in the scope of for loop, and use const_iterator

[Henrik Grunell, 2013/10/02 12:47:18]

Done.

+      it = params->meta_data.begin();
+  for (; it != params->meta_data.end(); ++it)
+    meta_data[(*it)->key] = (*it)->value;
+
+  WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
+      &WebrtcLoggingPrivateSetMetaDataFunction::SetMetaDataCallback, this);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::SetMetaData, webrtc_logging_handler_host,
+      meta_data, callback));

[Jói, 2013/09/27 14:39:53]

Just noting it here, probably not worth optimizing if the meta_data map is
generally fairly small: This will cause the entire map to be copied into the
posted task. If it's large you could use a linked_ptr<> of the map type instead.

[Henrik Grunell, 2013/10/02 12:47:18]

Yes, it's expected to be in the order of 5 entries. I'll leave it unless you or
anyone else objects.

+
+  return true;
+}
+
+void WebrtcLoggingPrivateSetMetaDataFunction::SetMetaDataCallback(
+    bool success, std::string error_message) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!success)
+    SetError(error_message);
+  SendResponse(success);
 }
 
 WebrtcLoggingPrivateStartFunction::WebrtcLoggingPrivateStartFunction() {}
 
 WebrtcLoggingPrivateStartFunction::~WebrtcLoggingPrivateStartFunction() {}
 
 bool WebrtcLoggingPrivateStartFunction::RunImpl() {
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  std::string app_url;
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderViewHost(render_view_host());
+  if (web_contents)
+    app_url = web_contents->GetLastCommittedURL().spec();
+
+  WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
+      &WebrtcLoggingPrivateStartFunction::StartCallback, this);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::StartLogging, webrtc_logging_handler_host,
+      app_url, callback));
+
+  return true;
 }
 
-void WebrtcLoggingPrivateStartFunction::StartCallback(bool success) {
+void WebrtcLoggingPrivateStartFunction::StartCallback(
+    bool success, std::string error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  // TODO(grunell): Implement set lastError.
-  NOTIMPLEMENTED();
+  if (!success)
+    SetError(error_message);
   SendResponse(success);
 }
 
 WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::
 WebrtcLoggingPrivateSetUploadOnRenderCloseFunction() {}
 
 WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::
 ~WebrtcLoggingPrivateSetUploadOnRenderCloseFunction() {}
 
 bool WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::RunImpl() {
   scoped_ptr<SetUploadOnRenderClose::Params> params(
       SetUploadOnRenderClose::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  webrtc_logging_handler_host->set_upload_log_on_render_close(
+      params->should_upload);
+
+  return true;
 }
 
 WebrtcLoggingPrivateStopFunction::WebrtcLoggingPrivateStopFunction() {}
 
 WebrtcLoggingPrivateStopFunction::~WebrtcLoggingPrivateStopFunction() {}
 
 bool WebrtcLoggingPrivateStopFunction::RunImpl() {
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
+      &WebrtcLoggingPrivateStopFunction::StopCallback, this);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::StopLogging, webrtc_logging_handler_host,
+      callback));
+
+  return true;
 }
 
-void WebrtcLoggingPrivateStopFunction::StopCallback(bool success) {
+void WebrtcLoggingPrivateStopFunction::StopCallback(
+    bool success, std::string error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  // TODO(grunell): Implement set lastError.
-  NOTIMPLEMENTED();
+  if (!success)
+    SetError(error_message);
   SendResponse(success);
 }
 
 WebrtcLoggingPrivateUploadFunction::WebrtcLoggingPrivateUploadFunction() {}
 
 WebrtcLoggingPrivateUploadFunction::~WebrtcLoggingPrivateUploadFunction() {}
 
 bool WebrtcLoggingPrivateUploadFunction::RunImpl() {
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind(
+      &WebrtcLoggingPrivateUploadFunction::UploadCallback, this);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::UploadLog, webrtc_logging_handler_host,
+      callback));
+
+  return true;
 }
 
 void WebrtcLoggingPrivateUploadFunction::UploadCallback(
-    bool success, std::string report_id) {
+    bool success, std::string report_id, std::string error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  api::webrtc_logging_private::UploadResult result;
-  result.report_id = report_id;
-  // TODO(grunell): Implement set lastError.
-  NOTIMPLEMENTED();
+  if (success) {
+    api::webrtc_logging_private::UploadResult result;
+    result.report_id = report_id;
+    SetResult(result.ToValue().release());
+  } else {
+    SetError(error_message);
+  }
   SendResponse(success);
 }
 
 WebrtcLoggingPrivateDiscardFunction::WebrtcLoggingPrivateDiscardFunction() {}
 
 WebrtcLoggingPrivateDiscardFunction::~WebrtcLoggingPrivateDiscardFunction() {}
 
 bool WebrtcLoggingPrivateDiscardFunction::RunImpl() {
-  // TODO(grunell): Implement.
-  NOTIMPLEMENTED();
-  return false;
+  content::RenderProcessHost* host = render_view_host()->GetProcess();
+  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+
+  WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
+      &WebrtcLoggingPrivateDiscardFunction::DiscardCallback, this);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::DiscardLog, webrtc_logging_handler_host,
+      callback));
+
+  return true;
 }
 
-void WebrtcLoggingPrivateDiscardFunction::DiscardCallback(bool success) {
+void WebrtcLoggingPrivateDiscardFunction::DiscardCallback(
+    bool success, std::string error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  // TODO(grunell): Implement set lastError.
-  NOTIMPLEMENTED();
+  if (!success)
+    SetError(error_message);
   SendResponse(success);
 }
 
 }  // namespace extensions