[GCM] Fix memory leaks

google_apis/gcm/engine/mcs_client.cc

 // Copyright 2013 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 "google_apis/gcm/engine/mcs_client.h"
 
 #include "base/basictypes.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 91 matching lines @@
       weak_ptr_factory_(this) {
 }
 
 MCSClient::~MCSClient() {
 }
 
 void MCSClient::Initialize(
     const ErrorCallback& error_callback,
     const OnMessageReceivedCallback& message_received_callback,
     const OnMessageSentCallback& message_sent_callback,
-    const GCMStore::LoadResult& load_result) {
+    scoped_ptr<GCMStore::LoadResult> load_result) {
   DCHECK_EQ(state_, UNINITIALIZED);
 
   state_ = LOADED;
   mcs_error_callback_ = error_callback;
   message_received_callback_ = message_received_callback;
   message_sent_callback_ = message_sent_callback;
 
   connection_factory_->Initialize(
       base::Bind(&MCSClient::ResetStateAndBuildLoginRequest,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&MCSClient::HandlePacketFromWire,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&MCSClient::MaybeSendMessage,
                  weak_ptr_factory_.GetWeakPtr()));
   connection_handler_ = connection_factory_->GetConnectionHandler();
 
   stream_id_out_ = 1;  // Login request is hardcoded to id 1.
 
-  android_id_ = load_result.device_android_id;
-  security_token_ = load_result.device_security_token;
+  android_id_ = load_result->device_android_id;
+  security_token_ = load_result->device_security_token;
 
   if (android_id_ == 0) {
     DVLOG(1) << "No device credentials found, assuming new client.";
     // No need to try and load RMQ data in that case.
     return;
   }
 
   // |android_id_| is non-zero, so should |security_token_|.
   DCHECK_NE(0u, security_token_) << "Security token invalid, while android id"
                                  << " is non-zero.";
 
-  DVLOG(1) << "RMQ Load finished with " << load_result.incoming_messages.size()
+  DVLOG(1) << "RMQ Load finished with " << load_result->incoming_messages.size()
            << " incoming acks pending and "
-           << load_result.outgoing_messages.size()
+           << load_result->outgoing_messages.size()
            << " outgoing messages pending.";
 
-  restored_unackeds_server_ids_ = load_result.incoming_messages;
+  restored_unackeds_server_ids_ = load_result->incoming_messages;
 
   // First go through and order the outgoing messages by recency.
   std::map<uint64, google::protobuf::MessageLite*> ordered_messages;
   std::vector<PersistentId> expired_ttl_ids;
-  for (std::map<PersistentId, google::protobuf::MessageLite*>::const_iterator
-           iter = load_result.outgoing_messages.begin();
-       iter != load_result.outgoing_messages.end(); ++iter) {
+  for (GCMStore::OutgoingMessageMap::iterator iter =
+           load_result->outgoing_messages.begin();
+       iter != load_result->outgoing_messages.end(); ++iter) {
     uint64 timestamp = 0;
     if (!base::StringToUint64(iter->first, &timestamp)) {
       LOG(ERROR) << "Invalid restored message.";
       // TODO(fgorski): Error: data unreadable
       mcs_error_callback_.Run();
       return;
     }
 
     // Check if the TTL has expired for this message.
     if (HasTTLExpired(*iter->second, clock_)) {
       expired_ttl_ids.push_back(iter->first);
       NotifyMessageSendStatus(*iter->second, TTL_EXCEEDED);
-      delete iter->second;
       continue;
     }
 
-    ordered_messages[timestamp] = iter->second;
+    ordered_messages[timestamp] = iter->second.release();
   }
 
   if (!expired_ttl_ids.empty()) {
     gcm_store_->RemoveOutgoingMessages(
         expired_ttl_ids,
         base::Bind(&MCSClient::OnGCMUpdateFinished,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // Now go through and add the outgoing messages to the send queue in their
   // appropriate order (oldest at front, most recent at back).
-  for (std::map<uint64, google::protobuf::MessageLite*>::const_iterator
+  for (std::map<uint64, google::protobuf::MessageLite*>::iterator
            iter = ordered_messages.begin();
        iter != ordered_messages.end(); ++iter) {
     ReliablePacketInfo* packet_info = new ReliablePacketInfo();
     packet_info->protobuf.reset(iter->second);
     packet_info->tag = GetMCSProtoTag(*iter->second);
     packet_info->persistent_id = base::Uint64ToString(iter->first);
     to_send_.push_back(make_linked_ptr(packet_info));
   }
 }
 
@@ skipping 19 matching lines @@
   DCHECK_GE(ttl, 0);
   if (to_send_.size() > kMaxSendQueueSize) {
     NotifyMessageSendStatus(message.GetProtobuf(), QUEUE_SIZE_LIMIT_REACHED);
     return;
   }
   if (message.size() > kMaxMessageBytes) {
     NotifyMessageSendStatus(message.GetProtobuf(), MESSAGE_TOO_LARGE);
     return;
   }
 
-  ReliablePacketInfo* packet_info = new ReliablePacketInfo();
+  scoped_ptr<ReliablePacketInfo> packet_info(new ReliablePacketInfo());
   packet_info->tag = message.tag();
   packet_info->protobuf = message.CloneProtobuf();
 
   if (ttl > 0) {
     PersistentId persistent_id = GetNextPersistentId();
     DVLOG(1) << "Setting persistent id to " << persistent_id;
     packet_info->persistent_id = persistent_id;
     SetPersistentId(persistent_id,
                     packet_info->protobuf.get());
     if (!gcm_store_->AddOutgoingMessage(
             persistent_id,
             MCSMessage(message.tag(),
                        *(packet_info->protobuf)),
             base::Bind(&MCSClient::OnGCMUpdateFinished,
                        weak_ptr_factory_.GetWeakPtr()))) {
       NotifyMessageSendStatus(message.GetProtobuf(),
                               APP_QUEUE_SIZE_LIMIT_REACHED);
       return;
     }
   } else if (!connection_factory_->IsEndpointReachable()) {
     DVLOG(1) << "No active connection, dropping message.";
     NotifyMessageSendStatus(message.GetProtobuf(), NO_CONNECTION_ON_ZERO_TTL);
     return;
   }
-  to_send_.push_back(make_linked_ptr(packet_info));
+  to_send_.push_back(make_linked_ptr(packet_info.release()));
   MaybeSendMessage();
 }
 
 void MCSClient::Destroy() {
   gcm_store_->Destroy(base::Bind(&MCSClient::OnGCMUpdateFinished,
                                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MCSClient::ResetStateAndBuildLoginRequest(
     mcs_proto::LoginRequest* request) {
@@ skipping 478 matching lines @@
   const mcs_proto::DataMessageStanza* data_message_stanza =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf);
   message_sent_callback_.Run(
       data_message_stanza->device_user_id(),
       data_message_stanza->category(),
       data_message_stanza->id(),
       status);
 }
 
 } // namespace gcm