Add the whispernet proxy.

chrome/browser/extensions/api/copresence_private/copresence_private_api.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 "chrome/browser/extensions/api/copresence_private/copresence_private_api.h"
+
+#include "base/lazy_instance.h"
+#include "base/stl_util.h"
+#include "chrome/browser/copresence/chrome_whispernet_client.h"
+#include "chrome/common/extensions/api/copresence_private.h"
+#include "components/copresence/public/whispernet_client.h"
+#include "media/base/audio_bus.h"
+
+namespace extensions {
+
+// This code is only for testing while we don't have the rest of the
+// CopresenceAPI service which will actually give us the whispernet client.
+// Once we add that code, this entire namespace will go away.
+namespace util {

[not at google - send to devlin, 2014/07/31 15:24:17]

I don't think the namespace is necessary.

[rkc, 2014/07/31 23:12:52]

Done.

+
+copresence::WhispernetClient* g_whispernet_client = NULL;
+
+copresence::WhispernetClient* GetWhispernetClient(
+    content::BrowserContext* context) {
+  if (!g_whispernet_client)
+    g_whispernet_client = new ChromeWhispernetClient(context);

[not at google - send to devlin, 2014/07/31 15:24:17]

this is a leak, use base::LazyInstance.

[rkc, 2014/07/31 23:12:53]

This code will never get exercised, removed. This function is _only in place
till we land the rest of the Copresence API code.
This code will be replaced by
https://codereview.chromium.org/428113002/diff/100001/chrome/browser/extensio...

Done.

+  return g_whispernet_client;
+}
+
+}  // namespace util
+
+// Copresence Private functions.
+
+// CopresenceSendFoundFunction implementation:
+bool CopresencePrivateSendFoundFunction::RunSync() {
+  if (!util::GetWhispernetClient(browser_context()) ||

[not at google - send to devlin, 2014/07/31 15:24:17]

how can !util::GetWhispernetClient(browser_context()) be NULL? it looks like you
unconditionally create it.

likewise all callers.

and given you use this condition for every function, consider creating a
CopresencePrivateFunction class which contains a method like IsAvailable() or
whatever.

[rkc, 2014/07/31 23:12:52]

Answered in the comment above :) The current GetWhispernetClient() method is
only a placeholder.

[not at google - send to devlin, 2014/07/31 23:31:17]

you haven't Done the second part of this comment.

[rkc, 2014/08/01 19:20:00]

Done.

+      util::GetWhispernetClient(browser_context())
+          ->GetTokensCallback()
+          .is_null()) {
+    return true;

[not at google - send to devlin, 2014/07/31 15:24:17]

seems like this should be an error?

[rkc, 2014/07/31 23:12:52]

If we don't have a callback registered right now, that just means that currently
we don't want to handle these tokens and we can safely drop them. We will have a
registered callback when we want to start receiving tokens. This is intended
behavior since we may simply unregister a callback (register an empty callback)
to stop receiving samples/tokens from Whispernet, but we don't want the
extension to get an exception when we do.

+  }
+
+  scoped_ptr<api::copresence_private::SendFound::Params> params(
+      api::copresence_private::SendFound::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  util::GetWhispernetClient(browser_context())->GetTokensCallback().Run(
+      params->tokens);
+  return true;
+}
+
+// CopresenceSendEncodedFunction implementation:
+bool CopresencePrivateSendSamplesFunction::RunSync() {
+  if (!util::GetWhispernetClient(browser_context()) ||
+      util::GetWhispernetClient(browser_context())
+          ->GetSamplesCallback()
+          .is_null()) {
+    return true;
+  }
+
+  scoped_ptr<api::copresence_private::SendSamples::Params> params(
+      api::copresence_private::SendSamples::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  scoped_refptr<media::AudioBusRefCounted> samples =
+      media::AudioBusRefCounted::Create(1,
+                                        params->samples.size() / sizeof(float));
+
+  memcpy(samples->channel(0),
+         string_as_array(&params->samples),
+         params->samples.size());

[not at google - send to devlin, 2014/07/31 15:24:17]

this doesn't look safe to me, where is the guarantee that params->samples.size()
is <= the size of samples->channel(0)?

[rkc, 2014/07/31 23:12:52]

The AudioBusRefCounted constructor ensures that we have enough memory in the
array we are memcpy'ing into. It allocate an aligned float array of the size
params->samples.size() / sizeof(float); i.e., the exact amount of memory that
params->samples.size() is.

+
+  util::GetWhispernetClient(browser_context())->GetSamplesCallback().Run(
+      params->token, samples);

[not at google - send to devlin, 2014/07/31 15:24:17]

should this take ownership of |samples|, and |samples| be a scoped_ptr with
.Pass()? refcounting should be a last resort.

[rkc, 2014/07/31 23:12:52]

We store the samples in STL data structures, and in multiple of those. This
underwent discussion with //media owners before we settled on using RefCounted
(and added a RefCounted audio bus to the audio code, only for this purpose).

[not at google - send to devlin, 2014/07/31 23:31:17]

ref counting doesn't make good interfaces. It seems like the intention is most
definitely to pass ownership to this samples callback, so it should be a
scoped_ptr. what the whispernet client does with that pointer after it takes it
its own business.

the comment says "only use this when it's impossible to use scoped_ptr":

https://code.google.com/p/chromium/codesearch#chromium/src/media/base/audio_b...

doesn't seem impossible to me.

[rkc, 2014/08/01 19:20:00]

Discussed offline.

+  return true;
+}
+
+// CopresenceSendDetectFunction implementation:
+bool CopresencePrivateSendDetectFunction::RunSync() {
+  if (!util::GetWhispernetClient(browser_context()) ||
+      util::GetWhispernetClient(browser_context())
+          ->GetDetectBroadcastCallback()
+          .is_null()) {
+    return true;
+  }
+
+  scoped_ptr<api::copresence_private::SendDetect::Params> params(
+      api::copresence_private::SendDetect::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  util::GetWhispernetClient(browser_context())
+      ->GetDetectBroadcastCallback()
+      .Run(params->detected);
+  return true;
+}
+
+// CopresenceSendInitializedFunction implementation:
+bool CopresencePrivateSendInitializedFunction::RunSync() {
+  LOG(ERROR) << "RKC: Got Init! context is: " << browser_context();

[not at google - send to devlin, 2014/07/31 15:24:17]

remove debugging?

[rkc, 2014/07/31 23:12:52]

Whoops.
Done.

+
+  if (!util::GetWhispernetClient(browser_context()) ||
+      util::GetWhispernetClient(browser_context())
+          ->GetInitializedCallback()
+          .is_null()) {
+    return true;
+  }
+
+  LOG(ERROR) << "RKC: Got Init and got profile!!";

[not at google - send to devlin, 2014/07/31 15:24:17]

remove debugging?

[rkc, 2014/07/31 23:12:52]

Done.

+
+  scoped_ptr<api::copresence_private::SendInitialized::Params> params(
+      api::copresence_private::SendInitialized::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  util::GetWhispernetClient(browser_context())->GetInitializedCallback().Run(
+      params->success);
+  return true;
+}
+
+void SetWhispernetClientForTesting(copresence::WhispernetClient* client) {
+  util::g_whispernet_client = client;
+}
+
+}  // namespace extensions