Deleting the copresence API.

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 <memory>
-#include <string>
-#include <utility>
-#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";
-  }
-}
-
-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>
-std::unique_ptr<DictionaryValue> FormatToken(const T& token) {
-  std::unique_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;
-}
-
-// Retrieve the CopresenceService, if any.
-CopresenceService* GetCopresenceService(WebUI* web_ui) {
-  DCHECK(web_ui);
-  return CopresenceService::GetFactoryInstance()->Get(
-      web_ui->GetWebContents()->GetBrowserContext());
-}
-
-// Safely retrieve the CopresenceState, if any.
-copresence::CopresenceState* GetCopresenceState(CopresenceService* service) {
-  // During shutdown, there may be no CopresenceService.
-  return service && service->manager() ? service->manager()->state() : nullptr;
-}
-
-// Safely retrieve the CopresenceState, if any. It would be cleaner if we could
-// put this into CopresenceUIHandler and call WebUIMessageHandler::web_ui()
-// instead of taking an argument. However, it turns out that web_ui() returns
-// null when called in the constructor. So we pass in the web_ui explicitly.
-copresence::CopresenceState* GetCopresenceState(WebUI* web_ui) {
-  return GetCopresenceState(GetCopresenceService(web_ui));
-}
-
-}  // 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)));
-  web_ui()->RegisterMessageCallback(
-      "clearCopresenceState",
-      base::Bind(&CopresenceUIHandler::HandleClearState,
-                 base::Unretained(this)));
-}
-
-void CopresenceUIHandler::DirectivesUpdated() {
-  ListValue js_directives;
-  for (const Directive& directive : state_->active_directives()) {
-    std::unique_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(std::move(js_directive));
-  }
-
-  web_ui()->CallJavascriptFunctionUnsafe("refreshDirectives", js_directives);
-}
-
-void CopresenceUIHandler::TokenTransmitted(const TransmittedToken& token) {
-  web_ui()->CallJavascriptFunctionUnsafe("updateTransmittedToken",
-                                         *FormatToken(token));
-}
-
-void CopresenceUIHandler::TokenReceived(const ReceivedToken& token) {
-  web_ui()->CallJavascriptFunctionUnsafe("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);
-}
-
-void CopresenceUIHandler::HandleClearState(const ListValue* args) {
-  DCHECK(args->empty());
-
-  CopresenceService* service = GetCopresenceService(web_ui());
-  DCHECK(service);
-  service->ResetState();
-
-  // CopresenceService::ResetState() deletes the CopresenceState object
-  // we were using. We have to get the new one and reconnect to it.
-  state_ = GetCopresenceState(service);
-  DCHECK(state_);
-  state_->AddObserver(this);
-
-  web_ui()->CallJavascriptFunctionUnsafe("clearTokens");
-  DirectivesUpdated();
-}