[cast_channel] Make CastSocket not inherit from ApiResource

extensions/browser/api/cast_channel/cast_socket.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_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 38 matching lines @@
 
 // Helper for logging data with remote host IP and authentication state.
 // Assumes |ip_endpoint_| of type net::IPEndPoint and |channel_auth_| of enum
 // type ChannelAuthType are available in the current scope.
 #define CONNECTION_INFO() \
   "[" << ip_endpoint_.ToString() << ", auth=" << channel_auth_ << "] "
 #define VLOG_WITH_CONNECTION(level) VLOG(level) << CONNECTION_INFO()
 #define LOG_WITH_CONNECTION(level) LOG(level) << CONNECTION_INFO()
 
 namespace extensions {
-static base::LazyInstance<BrowserContextKeyedAPIFactory<
-    ApiResourceManager<api::cast_channel::CastSocket>>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
-
-// static
-template <>
-BrowserContextKeyedAPIFactory<
-    ApiResourceManager<api::cast_channel::CastSocket>>*
-ApiResourceManager<api::cast_channel::CastSocket>::GetFactoryInstance() {
-  return g_factory.Pointer();
-}
-
 namespace api {
 namespace cast_channel {
 namespace {
 
 bool IsTerminalState(proto::ConnectionState state) {
   return state == proto::CONN_STATE_FINISHED ||
          state == proto::CONN_STATE_ERROR || state == proto::CONN_STATE_TIMEOUT;
 }
 
 // Cert verifier which blindly accepts all certificates, regardless of validity.
 class FakeCertVerifier : public net::CertVerifier {
  public:
   FakeCertVerifier() {}
   ~FakeCertVerifier() override {}
 
   int Verify(const RequestParams& params,
              net::CRLSet*,
              net::CertVerifyResult* verify_result,
              const net::CompletionCallback&,
              std::unique_ptr<Request>*,
              const net::NetLogWithSource&) override {
     verify_result->Reset();
     verify_result->verified_cert = params.certificate();
     return net::OK;
   }
 };
 
 }  // namespace
 
-CastSocket::CastSocket(const std::string& owner_extension_id)
-    : ApiResource(owner_extension_id) {
-}
-
-bool CastSocket::IsPersistent() const {
-  return true;
-}
+CastSocket::CastSocket() {}
 
 CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
                                const net::IPEndPoint& ip_endpoint,
                                ChannelAuthType channel_auth,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities)
     : CastSocketImpl(owner_extension_id,
                      ip_endpoint,
                      channel_auth,
                      net_log,
                      timeout,
                      keep_alive,
                      logger,
                      device_capabilities,
                      AuthContext::Create()) {}
 
 CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
                                const net::IPEndPoint& ip_endpoint,
                                ChannelAuthType channel_auth,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities,
                                const AuthContext& auth_context)
-    : CastSocket(owner_extension_id),
-      owner_extension_id_(owner_extension_id),
+    : owner_extension_id_(owner_extension_id),
       channel_id_(0),
       ip_endpoint_(ip_endpoint),
       channel_auth_(channel_auth),
       net_log_(net_log),
       keep_alive_(keep_alive),
       logger_(logger),
       auth_context_(auth_context),
       connect_timeout_(timeout),
       connect_timeout_timer_(new base::OneShotTimer),
       is_canceled_(false),
@@ skipping 42 matching lines @@
 }
 
 bool CastSocketImpl::keep_alive() const {
   return keep_alive_;
 }
 
 bool CastSocketImpl::audio_only() const {
   return audio_only_;
 }
 
+const std::string& CastSocketImpl::owner_extension_id() const {
+  return owner_extension_id_;
+}
+
 std::unique_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
   net::AddressList addresses(ip_endpoint_);
   return std::unique_ptr<net::TCPClientSocket>(
       new net::TCPClientSocket(addresses, nullptr, net_log_, net_log_source_));
   // Options cannot be set on the TCPClientSocket yet, because the
   // underlying platform socket will not be created until Bind()
   // or Connect() is called.
 }
 
 std::unique_ptr<net::SSLClientSocket> CastSocketImpl::CreateSslSocket(
@@ skipping 414 matching lines @@
   VLOG_WITH_CONNECTION(1) << "SetErrorState " << error_state;
   DCHECK_EQ(CHANNEL_ERROR_NONE, error_state_);
   error_state_ = error_state;
   delegate_->OnError(error_state_);
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 #undef VLOG_WITH_CONNECTION