[chrome.cast.channel] Remove event logging.

extensions/browser/api/cast_channel/cast_channel_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 "extensions/browser/api/cast_channel/cast_channel_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/time/default_clock.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_socket.h"
 #include "extensions/browser/api/cast_channel/keep_alive_delegate.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "extensions/common/api/cast_channel/logging.pb.h"
 #include "net/base/ip_address.h"
@@ skipping 72 matching lines @@
 }
 
 bool IsValidConnectInfoIpAddress(const ConnectInfo& connect_info) {
   net::IPAddress ip_address;
   return ip_address.AssignFromIPLiteral(connect_info.ip_address);
 }
 
 }  // namespace
 
 CastChannelAPI::CastChannelAPI(content::BrowserContext* context)
-    : browser_context_(context),
-      logger_(new Logger(base::WrapUnique<base::Clock>(new base::DefaultClock),
-                         base::Time::UnixEpoch())) {
+    : browser_context_(context), logger_(new Logger()) {
   DCHECK(browser_context_);
 }
 
 // static
 CastChannelAPI* CastChannelAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<CastChannelAPI>::Get(context);
 }
 
 scoped_refptr<Logger> CastChannelAPI::GetLogger() {
   return logger_;
@@ skipping 188 matching lines @@
         extension_->id(), *ip_endpoint_, channel_auth_,
         ExtensionsBrowserClient::Get()->GetNetLog(),
         base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
                                               ? *connect_info.timeout
                                               : kDefaultConnectTimeoutMillis),
         liveness_timeout_ > base::TimeDelta(), api_->GetLogger(),
         connect_info.capabilities.get() ? *connect_info.capabilities
                                         : CastDeviceCapability::NONE);
   }
   new_channel_id_ = AddSocket(socket);
-  api_->GetLogger()->LogNewSocketEvent(*socket);
 
   // Construct read delegates.
   std::unique_ptr<api::cast_channel::CastTransport::Delegate> delegate(
       base::MakeUnique<CastMessageHandler>(
           base::Bind(&CastChannelAPI::SendEvent, api_->AsWeakPtr()), socket,
           api_->GetLogger()));
   if (socket->keep_alive()) {
     // Wrap read delegate in a KeepAliveDelegate for timeout handling.
     api::cast_channel::KeepAliveDelegate* keep_alive =
         new api::cast_channel::KeepAliveDelegate(
             socket, api_->GetLogger(), std::move(delegate), ping_interval_,
             liveness_timeout_);
     std::unique_ptr<base::Timer> injected_timer =
         api_->GetInjectedTimeoutTimerForTest();
     if (injected_timer) {
       keep_alive->SetTimersForTest(base::MakeUnique<base::Timer>(false, false),
                                    std::move(injected_timer));
     }
     delegate.reset(keep_alive);
   }
 
-  api_->GetLogger()->LogNewSocketEvent(*socket);
   socket->Connect(std::move(delegate),
                   base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
 void CastChannelOpenFunction::OnOpen(cast_channel::ChannelError result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "Connect finished, OnOpen invoked.";
   CastSocket* socket = GetSocket(new_channel_id_);
   if (!socket) {
     SetResultFromError(new_channel_id_, result);
@@ skipping 62 matching lines @@
   } else {
     SetResultFromSocket(*socket);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelCloseFunction::CastChannelCloseFunction() { }
 
 CastChannelCloseFunction::~CastChannelCloseFunction() { }
 
+bool CastChannelCloseFunction::PrePrepare() {
+  api_ = CastChannelAPI::Get(browser_context());
+  return CastChannelAsyncApiFunction::PrePrepare();
+}
+
 bool CastChannelCloseFunction::Prepare() {
   params_ = Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void CastChannelCloseFunction::AsyncWorkStart() {
   CastSocket* socket = GetSocket(params_->channel.channel_id);
   if (!socket) {
     SetResultFromError(params_->channel.channel_id,
                        cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   } else {
     socket->Close(base::Bind(&CastChannelCloseFunction::OnClose, this));
   }
 }
 
 void CastChannelCloseFunction::OnClose(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "CastChannelCloseFunction::OnClose result = " << result;
   int channel_id = params_->channel.channel_id;
   CastSocket* socket = GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     RemoveSocket(channel_id);
+    api_->GetLogger()->ClearLastErrors(channel_id);
   }
   AsyncWorkCompleted();
 }
 
-CastChannelGetLogsFunction::CastChannelGetLogsFunction() {
-}
-
-CastChannelGetLogsFunction::~CastChannelGetLogsFunction() {
-}
-
-bool CastChannelGetLogsFunction::PrePrepare() {
-  api_ = CastChannelAPI::Get(browser_context());
-  return CastChannelAsyncApiFunction::PrePrepare();
-}
-
-bool CastChannelGetLogsFunction::Prepare() {
-  return true;
-}
-
-void CastChannelGetLogsFunction::AsyncWorkStart() {
-  DCHECK(api_);
-
-  size_t length = 0;
-  std::unique_ptr<char[]> out = api_->GetLogger()->GetLogs(&length);
-  if (out.get()) {
-    SetResult(base::MakeUnique<base::BinaryValue>(std::move(out), length));
-  } else {
-    SetError("Unable to get logs.");
-  }
-
-  api_->GetLogger()->Reset();
-
-  AsyncWorkCompleted();
-}
-
 CastChannelOpenFunction::CastMessageHandler::CastMessageHandler(
     const EventDispatchCallback& ui_dispatch_cb,
     cast_channel::CastSocket* socket,
     scoped_refptr<Logger> logger)
     : ui_dispatch_cb_(ui_dispatch_cb), socket_(socket), logger_(logger) {
   DCHECK(socket_);
   DCHECK(logger_);
 }
 
 CastChannelOpenFunction::CastMessageHandler::~CastMessageHandler() {
@@ skipping 38 matching lines @@
                                          std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, socket_->owner_extension_id(),
                  base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::Start() {
 }
 
-CastChannelSetAuthorityKeysFunction::CastChannelSetAuthorityKeysFunction() {
-}
-
-CastChannelSetAuthorityKeysFunction::~CastChannelSetAuthorityKeysFunction() {
-}
-
-bool CastChannelSetAuthorityKeysFunction::Prepare() {
-  return true;
-}
-
-void CastChannelSetAuthorityKeysFunction::AsyncWorkStart() {
-  // TODO(eroman): crbug.com/601171: Delete this once the API is
-  // removed. It is currently a no-op.
-  AsyncWorkCompleted();
-}
-
 }  // namespace extensions