Improve GCM enum switch type safety

components/gcm_driver/gcm_client_impl.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 "components/gcm_driver/gcm_client_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 78 matching lines @@
 const char kSendErrorMessageIdKey[] = "google.message_id";
 const char kSubtypeKey[] = "subtype";
 const char kSendMessageFromValue[] = "gcm@chrome.com";
 const int64_t kDefaultUserSerialNumber = 0LL;
 const int kDestroyGCMStoreDelayMS = 5 * 60 * 1000;  // 5 minutes.
 
 GCMClient::Result ToGCMClientResult(MCSClient::MessageSendStatus status) {
   switch (status) {
     case MCSClient::QUEUED:
       return GCMClient::SUCCESS;
-    case MCSClient::QUEUE_SIZE_LIMIT_REACHED:
-      return GCMClient::NETWORK_ERROR;
-    case MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
-      return GCMClient::NETWORK_ERROR;
     case MCSClient::MESSAGE_TOO_LARGE:
       return GCMClient::INVALID_PARAMETER;
+    case MCSClient::QUEUE_SIZE_LIMIT_REACHED:
+    case MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
     case MCSClient::NO_CONNECTION_ON_ZERO_TTL:
-      return GCMClient::NETWORK_ERROR;
     case MCSClient::TTL_EXCEEDED:
       return GCMClient::NETWORK_ERROR;
     case MCSClient::SENT:
-    default:
+    case MCSClient::SEND_STATUS_COUNT:
       NOTREACHED();
       break;
   }
   return GCMClientImpl::UNKNOWN_ERROR;
 }
 
 void ToCheckinProtoVersion(
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     checkin_proto::ChromeBuildProto* android_build_info) {
-  checkin_proto::ChromeBuildProto_Platform platform;
+  checkin_proto::ChromeBuildProto_Platform platform =
+      checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
   switch (chrome_build_info.platform) {
     case GCMClient::PLATFORM_WIN:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_WIN;
       break;
     case GCMClient::PLATFORM_MAC:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_MAC;
       break;
     case GCMClient::PLATFORM_LINUX:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
       break;
     case GCMClient::PLATFORM_IOS:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_IOS;
       break;
     case GCMClient::PLATFORM_ANDROID:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_ANDROID;
       break;
     case GCMClient::PLATFORM_CROS:
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_CROS;
       break;
     case GCMClient::PLATFORM_UNKNOWN:
       // For unknown platform, return as LINUX.
       platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
       break;
-    default:
-      NOTREACHED();
-      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
-      break;
   }
   android_build_info->set_platform(platform);
 
-  checkin_proto::ChromeBuildProto_Channel channel;
+  checkin_proto::ChromeBuildProto_Channel channel =
+      checkin_proto::ChromeBuildProto_Channel_CHANNEL_UNKNOWN;
   switch (chrome_build_info.channel) {
     case GCMClient::CHANNEL_STABLE:
       channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_STABLE;
       break;
     case GCMClient::CHANNEL_BETA:
       channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_BETA;
       break;
     case GCMClient::CHANNEL_DEV:
       channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_DEV;
       break;
     case GCMClient::CHANNEL_CANARY:
       channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_CANARY;
       break;
     case GCMClient::CHANNEL_UNKNOWN:
       channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_UNKNOWN;
       break;
-    default:
-      NOTREACHED();
-      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_UNKNOWN;
-      break;
   }
   android_build_info->set_channel(channel);
 
   android_build_info->set_chrome_version(chrome_build_info.version);
 }
 
 MessageType DecodeMessageType(const std::string& value) {
   if (kMessageTypeDeletedMessagesKey == value)
     return DELETED_MESSAGES;
   if (kMessageTypeSendErrorKey == value)
@@ skipping 970 matching lines @@
     app_data->set_value(iter->second);
   }
 
   MCSMessage mcs_message(stanza);
   DVLOG(1) << "MCS message size: " << mcs_message.size();
   mcs_client_->SendMessage(mcs_message);
 }
 
 std::string GCMClientImpl::GetStateString() const {
   switch(state_) {
+    case GCMClientImpl::UNINITIALIZED:
+      return "UNINITIALIZED";
     case GCMClientImpl::INITIALIZED:
       return "INITIALIZED";
-    case GCMClientImpl::UNINITIALIZED:
-      return "UNINITIALIZED";
     case GCMClientImpl::LOADING:
       return "LOADING";
     case GCMClientImpl::LOADED:
       return "LOADED";
     case GCMClientImpl::INITIAL_DEVICE_CHECKIN:
       return "INITIAL_DEVICE_CHECKIN";
     case GCMClientImpl::READY:
       return "READY";
-    default:
-      NOTREACHED();
-      return std::string();
   }
+  NOTREACHED();
+  return std::string();
 }
 
 void GCMClientImpl::RecordDecryptionFailure(
     const std::string& app_id,
     GCMEncryptionProvider::DecryptionResult result) {
   recorder_.RecordDecryptionFailure(app_id, result);
 }
 
 void GCMClientImpl::SetRecording(bool recording) {
   recorder_.set_is_recording(recording);
@@ skipping 148 matching lines @@
     case DELETED_MESSAGES:
       recorder_.RecordDataMessageReceived(app_id, data_message_stanza.from(),
                                           data_message_stanza.ByteSize(), true,
                                           GCMStatsRecorder::DELETED_MESSAGES);
       delegate_->OnMessagesDeleted(app_id);
       break;
     case SEND_ERROR:
       HandleIncomingSendError(app_id, data_message_stanza, message_data);
       break;
     case UNKNOWN:
-    default:  // Treat default the same as UNKNOWN.
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << app_id << ".";
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const std::string& app_id,
     bool was_subtype,
     const mcs_proto::DataMessageStanza& data_message_stanza,
@@ skipping 83 matching lines @@
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm