Extensions Docs Server: Enum values do not show up if enum is a type

chrome/browser/extensions/api/socket/socket_api.cc

 // Copyright (c) 2012 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/extensions/api/socket/socket_api.h"
 
 #include "base/bind.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
@@ skipping 10 matching lines @@
 #include "net/base/net_util.h"
 
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
-const char kTCPOption[] = "tcp";
-const char kUDPOption[] = "udp";
-const char kUnknown[] = "unknown";
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kSocketTypeInvalidError[] = "Socket type is not supported";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
 const char kPermissionError[] = "Caller does not have permission";
 const char kNetworkListError[] = "Network lookup failed or unsupported";
 
 SocketAsyncApiFunction::SocketAsyncApiFunction()
     : manager_(NULL) {
 }
@@ skipping 69 matching lines @@
       src_id_(-1),
       event_notifier_(NULL) {
 }
 
 SocketCreateFunction::~SocketCreateFunction() {}
 
 bool SocketCreateFunction::Prepare() {
   params_ = api::socket::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
-  if (params_->type == kTCPOption) {
-    socket_type_ = kSocketTypeTCP;
-  } else if (params_->type == kUDPOption) {
-    socket_type_ = kSocketTypeUDP;
-  } else {
-    error_ = kSocketTypeInvalidError;
-    return false;
+  switch (params_->type) {
+    case extensions::api::socket::SOCKET_SOCKET_TYPE_TCP:
+      socket_type_ = kSocketTypeTCP;
+      break;
+    case extensions::api::socket::SOCKET_SOCKET_TYPE_UDP:
+      socket_type_ = kSocketTypeUDP;
+      break;
+    case extensions::api::socket::SOCKET_SOCKET_TYPE_NONE:
+      NOTREACHED();
+      break;
   }
+
   if (params_->options.get()) {
     scoped_ptr<DictionaryValue> options = params_->options->ToValue();
     src_id_ = ExtractSrcId(options.get());
     event_notifier_ = CreateEventNotifier(src_id_);
   }
 
   return true;
 }
 
 void SocketCreateFunction::Work() {
@@ skipping 386 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetInfoFunction::Work() {
   api::socket::SocketInfo info;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     // This represents what we know about the socket, and does not call through
     // to the system.
-    switch (socket->GetSocketType()) {
-      case Socket::TYPE_TCP:
-        info.socket_type = kTCPOption;
-        break;
-      case Socket::TYPE_UDP:
-        info.socket_type = kUDPOption;
-        break;
-      default:
-        NOTREACHED() << "Unknown socket type.";
-        info.socket_type = kUnknown;
-        break;
-    }
+    if (socket->GetSocketType() == Socket::TYPE_TCP)
+      info.socket_type = extensions::api::socket::SOCKET_SOCKET_TYPE_TCP;
+    else
+      info.socket_type = extensions::api::socket::SOCKET_SOCKET_TYPE_UDP;
     info.connected = socket->IsConnected();
 
     // Grab the peer address as known by the OS. This and the call below will
     // always succeed while the socket is connected, even if the socket has
     // been remotely closed by the peer; only reading the socket will reveal
     // that it should be closed locally.
     net::IPEndPoint peerAddress;
     if (socket->GetPeerAddress(&peerAddress)) {
       info.peer_address.reset(
           new std::string(peerAddress.ToStringWithoutPort()));
@@ skipping 53 matching lines @@
     info->name = i->name;
     info->address = net::IPAddressToString(i->address);
     create_arg.push_back(info);
   }
 
   results_ = api::socket::GetNetworkList::Results::Create(create_arg);
   SendResponse(true);
 }
 
 }  // namespace extensions