Adding the chrome://copresence page

chrome/browser/ui/webui/copresence_ui_handler.cc

Index: chrome/browser/ui/webui/copresence_ui_handler.cc
diff --git a/chrome/browser/ui/webui/copresence_ui_handler.cc b/chrome/browser/ui/webui/copresence_ui_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6ca423506069ca91eae2a46ea998587759a688d6
--- /dev/null
+++ b/chrome/browser/ui/webui/copresence_ui_handler.cc
@@ -0,0 +1,185 @@
+// 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/ui/webui/copresence_ui_handler.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/i18n/time_formatting.h"
+#include "base/strings/stringprintf.h"
+#include "base/time/time.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/api/copresence/copresence_api.h"
+#include "components/copresence/proto/chrome_only.pb.h"
+#include "components/copresence/proto/data.pb.h"
+#include "components/copresence/public/copresence_manager.h"
+#include "components/copresence/public/copresence_state.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_ui.h"
+
+using base::ListValue;
+using base::DictionaryValue;
+using content::WebUI;
+using copresence::Directive;
+using copresence::ReceivedToken;
+using copresence::SentToken;
+using extensions::CopresenceService;
+
+namespace {
+
+const int kMillisecondsPerMinute = 60 * 1000;
+const int kMillisecondsPerHour = 60 * kMillisecondsPerMinute;
+
+std::string FormatInstructionType(
+    copresence::TokenInstructionType directive_type) {
+  if (directive_type == copresence::TRANSMIT) {
+    return "Broadcast";

[rkc, 2014/12/05 19:46:36]

Any reason we aren't just sticking with "Transmit/Receive"?

[Charlie, 2014/12/05 21:26:08]

Broadcast and scan is the latest terminology used by the server protos. Although
"receive" does seem better than "scan".

Done.

+  } else {
+    DCHECK(directive_type == copresence::RECEIVE);
+    return "Scan";
+  }
+}
+
+std::string FormatMedium(copresence::TokenMedium medium) {
+  if (medium == copresence::AUDIO_ULTRASOUND_PASSBAND) {
+    return "Ultrasound";
+  } else {
+    DCHECK(medium == copresence::AUDIO_AUDIBLE_DTMF);
+    return "Audible";
+  }
+}
+
+std::string FormatDuration(int64 milliseconds) {
+  DCHECK_GE(milliseconds, 0);
+  if (milliseconds < 1000) {
+    return base::StringPrintf("%ld milliseconds", milliseconds);
+  } else if (milliseconds < kMillisecondsPerMinute) {
+    int seconds = milliseconds / 1000;
+    return seconds == 1 ? "1 second" :
+        base::StringPrintf("%d seconds", seconds);
+  } else if (milliseconds < kMillisecondsPerHour) {
+    int minutes = milliseconds / kMillisecondsPerMinute;
+    return minutes == 1 ? "1 minute" :
+        base::StringPrintf("%d minutes", minutes);
+  } else {
+    int hours = milliseconds / kMillisecondsPerHour;
+    return hours == 1 ? "1 hour" :
+        base::StringPrintf("%d hours", hours);
+  }
+}
+
+base::Time ParseTimestamp(int64 milliseconds) {
+  return base::Time::UnixEpoch() +
+         base::TimeDelta::FromMilliseconds(milliseconds);
+}
+
+base::string16 FormatTime(int64 milliseconds) {
+  return base::TimeFormatTimeOfDay(ParseTimestamp(milliseconds));
+}
+
+std::string FormatStatus(const SentToken& token) {
+  DCHECK(token.has_stop_time_millis());
+  bool playing = ParseTimestamp(token.stop_time_millis()) < base::Time::Now();
+  std::string status = playing ? "Played" : "Playing";
+  if (token.broadcast_confirmed())
+    status += " (Confirmed)";
+  return status;
+}
+
+std::string FormatStatus(const ReceivedToken& token) {
+  if (token.has_valid())
+    return token.valid() ? "Valid" : "Invalid";
+  else
+    return "Unknown";
+}
+
+template<class T>
+scoped_ptr<DictionaryValue> FormatToken(const T& token) {
+  scoped_ptr<DictionaryValue> js_token(new DictionaryValue);
+
+  js_token->SetString("id", token.id());
+  js_token->SetString("status", FormatStatus(token));
+  js_token->SetString("medium", FormatMedium(token.medium()));
+  js_token->SetString("time", FormatTime(token.start_time_millis()));
+
+  return js_token.Pass();
+}
+
+// Safely retrieve the CopresenceState, if any.
+copresence::CopresenceState* GetCopresenceState(
+    WebUI* web_ui) {
+  DCHECK(web_ui && web_ui->GetWebContents());
+  CopresenceService* service = CopresenceService::GetFactoryInstance()->Get(
+      web_ui->GetWebContents()->GetBrowserContext());
+  return service && service->manager() ? service->manager()->state() : nullptr;
+}
+
+}  // namespace
+
+
+// Public functions.
+
+CopresenceUIHandler::CopresenceUIHandler(WebUI* web_ui)
+    : state_(GetCopresenceState(web_ui)) {
+  DCHECK(state_);
+  state_->AddObserver(this);
+}
+
+CopresenceUIHandler::~CopresenceUIHandler() {
+  // Check if the CopresenceService is still up before unregistering.
+  state_ = GetCopresenceState(web_ui());
+  if (state_)
+    state_->RemoveObserver(this);
+}
+
+
+// Private functions.
+
+void CopresenceUIHandler::RegisterMessages() {
+  web_ui()->RegisterMessageCallback(
+      "populateCopresenceState",
+      base::Bind(&CopresenceUIHandler::PopulateState,
+                 base::Unretained(this)));
+}
+
+void CopresenceUIHandler::UpdateDirectives(
+    const std::vector<Directive>& active_directives) {

[rkc, 2014/12/05 19:46:36]

Why does this parameter exist? You always call this on
state_->active_directives(), which this function has access to also.

[Charlie, 2014/12/05 21:26:08]

Seemed more natural, but it's true that it's redundant. Fixed.

+  ListValue js_directives;
+  for (const Directive& directive : active_directives) {
+    DictionaryValue* js_directive = new DictionaryValue;
+
+    js_directive->SetString("type", FormatInstructionType(
+        directive.token_instruction().token_instruction_type()));
+    js_directive->SetString("medium", FormatMedium(
+        directive.token_instruction().medium()));
+    js_directive->SetString("duration", FormatDuration(directive.ttl_millis()));
+
+    js_directives.Append(js_directive);
+  }
+
+  web_ui()->CallJavascriptFunction("refreshDirectives", js_directives);
+}
+
+void CopresenceUIHandler::TokenSent(const copresence::SentToken& token) {
+  web_ui()->CallJavascriptFunction("updateSentToken",
+                                   *FormatToken(token));
+}
+
+void CopresenceUIHandler::TokenReceived(
+    const copresence::ReceivedToken& token) {
+  web_ui()->CallJavascriptFunction("updateReceivedToken",
+                                   *FormatToken(token));
+}
+
+void CopresenceUIHandler::PopulateState(const ListValue* args) {
+  DCHECK(args->empty()) << "populateCopresenceState() doesn't take arguments";
+  UpdateDirectives(state_->active_directives());
+  for (const auto& token_entry : state_->sent_tokens())
+    TokenSent(token_entry.second);

[rkc, 2014/12/05 19:46:36]

nit: Making calls to JS is expensive. Populate an array with the sent and
received tokens and send them off to JS in one call.

[Charlie, 2014/12/05 23:02:37]

Added a TODO. To make a difference, this requires reworking the JS to handle
batches intelligently, instead of the obvious n^2 solution.

+  for (const auto& token_entry : state_->received_tokens())
+    TokenReceived(token_entry.second);
+}