Adding the chrome://copresence page

chrome/browser/ui/webui/copresence_ui_handler.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/ui/webui/copresence_ui_handler.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/i18n/time_formatting.h"
+#include "base/time/time.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/api/copresence/copresence_api.h"
+#include "components/copresence/proto/data.pb.h"
+#include "components/copresence/public/copresence_manager.h"
+#include "components/copresence/public/copresence_state.h"
+#include "components/copresence/tokens.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_ui.h"
+#include "ui/base/l10n/time_format.h"
+
+using base::ListValue;
+using base::DictionaryValue;
+using content::WebUI;
+using copresence::Directive;
+using copresence::ReceivedToken;
+using copresence::TransmittedToken;
+using extensions::CopresenceService;
+
+// TODO(ckehoe): Make debug strings translatable?
+
+namespace {
+
+std::string FormatInstructionType(
+    copresence::TokenInstructionType directive_type) {
+  switch (directive_type) {
+    case copresence::TRANSMIT:
+      return "Transmit";
+
+    case copresence::RECEIVE:
+      return "Receive";
+
+    default:
+      NOTREACHED();
+      return "Unknown";
+  }
+}
+
+std::string FormatMedium(copresence::TokenMedium medium) {
+  switch (medium) {
+    case copresence::AUDIO_ULTRASOUND_PASSBAND:
+      return "Ultrasound";
+
+    case copresence::AUDIO_AUDIBLE_DTMF:
+      return "Audible";
+
+    default:
+      NOTREACHED();
+      return "Unknown";
+  }

[Dan Beam, 2014/12/20 03:44:20]

I meant remove the default: and add a NOTREACHED() return "Unknown" after the
switch.  putting a default means that adding new values will never break this
code (which we want to happen).

[Charlie, 2014/12/20 06:53:35]

I'm not following. I think the code behaves the same whether NOTREACHED() is in
a default case, or after the switch with no default. Either way, unhandled
values will hit NOTREACHED().

In this particular case, there are actually other TokenMediums that we don't
handle, because we don't support them. However we tell the server that we don't
support them, so it shouldn't send them to us.

+}
+
+std::string ConvertStatus(const TransmittedToken& token) {
+  bool done = token.stop_time < base::Time::Now();
+  std::string status = done ? "done" : "active";
+  if (token.broadcast_confirmed)
+    status += " confirmed";
+  return status;
+}
+
+std::string ConvertStatus(const ReceivedToken& token) {
+  switch (token.valid) {
+    case ReceivedToken::VALID:
+      return "valid";
+
+    case ReceivedToken::INVALID:
+      return "invalid";
+
+    case ReceivedToken::UNKNOWN:
+      return std::string();
+
+    default:
+      NOTREACHED();
+      return std::string();
+  }
+}
+
+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("statuses", ConvertStatus(token));
+  js_token->SetString("medium", FormatMedium(token.medium));
+  DCHECK(!token.start_time.is_null());
+  js_token->SetString("time",
+      base::TimeFormatTimeOfDay(token.start_time));
+
+  return js_token.Pass();
+}
+
+// Safely retrieve the CopresenceState, if any.
+copresence::CopresenceState* GetCopresenceState(WebUI* web_ui) {
+  // This function must be called with a valid web_ui.
+  DCHECK(web_ui);
+  DCHECK(web_ui->GetWebContents());
+
+  // During shutdown, however, there may be no CopresenceService.
+  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::HandlePopulateState,
+                 base::Unretained(this)));
+}
+
+void CopresenceUIHandler::DirectivesUpdated() {
+  ListValue js_directives;
+  for (const Directive& directive : state_->active_directives()) {
+    scoped_ptr<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", ui::TimeFormat::Simple(
+        ui::TimeFormat::FORMAT_DURATION,
+        ui::TimeFormat::LENGTH_LONG,
+        base::TimeDelta::FromMilliseconds(directive.ttl_millis())));
+
+    js_directives.Append(js_directive.release());
+  }
+
+  web_ui()->CallJavascriptFunction("refreshDirectives", js_directives);
+}
+
+void CopresenceUIHandler::TokenTransmitted(const TransmittedToken& token) {
+  web_ui()->CallJavascriptFunction("updateTransmittedToken",
+                                   *FormatToken(token));
+}
+
+void CopresenceUIHandler::TokenReceived(const ReceivedToken& token) {
+  web_ui()->CallJavascriptFunction("updateReceivedToken",
+                                   *FormatToken(token));
+}
+
+void CopresenceUIHandler::HandlePopulateState(const ListValue* args) {
+  DCHECK(args->empty());
+  DirectivesUpdated();
+  // TODO(ckehoe): Pass tokens to JS as a batch.
+  for (const auto& token_entry : state_->transmitted_tokens())
+    TokenTransmitted(token_entry.second);
+  for (const auto& token_entry : state_->received_tokens())
+    TokenReceived(token_entry.second);
+}