[GCM] Fix memory leaks

google_apis/gcm/engine/gcm_store_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 "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 106 matching lines @@
   void RemoveUserSerialNumber(const std::string& username,
                               const UpdateCallback& callback);
   void SetNextSerialNumber(int64 serial_number, const UpdateCallback& callback);
 
  private:
   friend class base::RefCountedThreadSafe<Backend>;
   ~Backend();
 
   bool LoadDeviceCredentials(uint64* android_id, uint64* security_token);
   bool LoadIncomingMessages(std::vector<std::string>* incoming_messages);
-  bool LoadOutgoingMessages(
-      std::map<std::string, google::protobuf::MessageLite*>* outgoing_messages);
+  bool LoadOutgoingMessages(OutgoingMessageMap* outgoing_messages);
   bool LoadNextSerialNumber(int64* next_serial_number);
   bool LoadUserSerialNumberMap(
       std::map<std::string, int64>* user_serial_number_map);
 
   const base::FilePath path_;
   scoped_refptr<base::SequencedTaskRunner> foreground_task_runner_;
 
   scoped_ptr<leveldb::DB> db_;
 };
 
 GCMStoreImpl::Backend::Backend(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> foreground_task_runner)
     : path_(path), foreground_task_runner_(foreground_task_runner) {}
 
 GCMStoreImpl::Backend::~Backend() {}
 
 void GCMStoreImpl::Backend::Load(const LoadCallback& callback) {
-  LoadResult result;
+  scoped_ptr<LoadResult> result(new LoadResult());
   if (db_.get()) {
     LOG(ERROR) << "Attempting to reload open database.";
-    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
+    foreground_task_runner_->PostTask(FROM_HERE,
+                                      base::Bind(callback,
+                                                 base::Passed(&result)));
     return;
   }
 
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::DB* db;
   leveldb::Status status =
       leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db);
   UMA_HISTOGRAM_BOOLEAN("GCM.LoadSucceeded", status.ok());
   if (!status.ok()) {
     LOG(ERROR) << "Failed to open database " << path_.value() << ": "
                << status.ToString();
-    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
+    foreground_task_runner_->PostTask(FROM_HERE,
+                                      base::Bind(callback,
+                                                 base::Passed(&result)));
     return;
   }
   db_.reset(db);
 
-  if (!LoadDeviceCredentials(&result.device_android_id,
-                             &result.device_security_token) ||
-      !LoadIncomingMessages(&result.incoming_messages) ||
-      !LoadOutgoingMessages(&result.outgoing_messages) ||
+  if (!LoadDeviceCredentials(&result->device_android_id,
+                             &result->device_security_token) ||
+      !LoadIncomingMessages(&result->incoming_messages) ||
+      !LoadOutgoingMessages(&result->outgoing_messages) ||
       !LoadNextSerialNumber(
-           &result.serial_number_mappings.next_serial_number) ||
+           &result->serial_number_mappings.next_serial_number) ||
       !LoadUserSerialNumberMap(
-           &result.serial_number_mappings.user_serial_numbers)) {
-    result.device_android_id = 0;
-    result.device_security_token = 0;
-    result.incoming_messages.clear();
-    STLDeleteContainerPairSecondPointers(result.outgoing_messages.begin(),
-                                         result.outgoing_messages.end());
-    result.outgoing_messages.clear();
-    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
+           &result->serial_number_mappings.user_serial_numbers)) {
+    result->device_android_id = 0;
+    result->device_security_token = 0;
+    result->incoming_messages.clear();
+    result->outgoing_messages.clear();
+    foreground_task_runner_->PostTask(FROM_HERE,
+                                      base::Bind(callback,
+                                                 base::Passed(&result)));
     return;
   }
 
   // Only record histograms if GCM had already been set up for this device.
-  if (result.device_android_id != 0 && result.device_security_token != 0) {
+  if (result->device_android_id != 0 && result->device_security_token != 0) {
     int64 file_size = 0;
     if (base::GetFileSize(path_, &file_size)) {
       UMA_HISTOGRAM_COUNTS("GCM.StoreSizeKB",
                            static_cast<int>(file_size / 1024));
     }
     UMA_HISTOGRAM_COUNTS("GCM.RestoredOutgoingMessages",
-                         result.outgoing_messages.size());
+                         result->outgoing_messages.size());
     UMA_HISTOGRAM_COUNTS("GCM.RestoredIncomingMessages",
-                         result.incoming_messages.size());
+                         result->incoming_messages.size());
     UMA_HISTOGRAM_COUNTS(
         "GCM.NumUsers",
-        result.serial_number_mappings.user_serial_numbers.size());
+        result->serial_number_mappings.user_serial_numbers.size());
   }
 
-  DVLOG(1) << "Succeeded in loading " << result.incoming_messages.size()
+  DVLOG(1) << "Succeeded in loading " << result->incoming_messages.size()
            << " unacknowledged incoming messages and "
-           << result.outgoing_messages.size()
+           << result->outgoing_messages.size()
            << " unacknowledged outgoing messages.";
-  result.success = true;
-  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
+  result->success = true;
+  foreground_task_runner_->PostTask(FROM_HERE,
+                                    base::Bind(callback,
+                                               base::Passed(&result)));
   return;
 }
 
 void GCMStoreImpl::Backend::Destroy(const UpdateCallback& callback) {
   DVLOG(1) << "Destroying GCM store.";
   db_.reset();
   const leveldb::Status s =
       leveldb::DestroyDB(path_.AsUTF8Unsafe(), leveldb::Options());
   if (s.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
@@ skipping 297 matching lines @@
       return false;
     }
     DVLOG(1) << "Found incoming message with id " << s.ToString();
     incoming_messages->push_back(s.ToString());
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadOutgoingMessages(
-    std::map<std::string, google::protobuf::MessageLite*>* outgoing_messages) {
+    OutgoingMessageMap* outgoing_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kOutgoingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kOutgoingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading incoming message with key " << s.ToString();
       return false;
     }
     uint8 tag = iter->value().data()[0];
     std::string id = ParseOutgoingKey(iter->key().ToString());
     scoped_ptr<google::protobuf::MessageLite> message(
         BuildProtobufFromTag(tag));
     if (!message.get() ||
         !message->ParseFromString(iter->value().ToString().substr(1))) {
       LOG(ERROR) << "Failed to parse outgoing message with id " << id
                  << " and tag " << tag;
       return false;
     }
     DVLOG(1) << "Found outgoing message with id " << id << " of type "
              << base::IntToString(tag);
-    (*outgoing_messages)[id] = message.release();
+    (*outgoing_messages)[id] = make_linked_ptr(message.release());
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadNextSerialNumber(int64* next_serial_number) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
@@ skipping 195 matching lines @@
                                           const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::RemoveUserSerialNumber,
                  backend_,
                  username,
                  callback));
 }
 
 void GCMStoreImpl::LoadContinuation(const LoadCallback& callback,
-                                    const LoadResult& result) {
-  if (!result.success) {
-    callback.Run(result);
+                                    scoped_ptr<LoadResult> result) {
+  if (!result->success) {
+    callback.Run(result.Pass());
     return;
   }
   int num_throttled_apps = 0;
-  for (std::map<std::string, google::protobuf::MessageLite*>::const_iterator
-           iter = result.outgoing_messages.begin();
-       iter != result.outgoing_messages.end(); ++iter) {
+  for (OutgoingMessageMap::const_iterator
+           iter = result->outgoing_messages.begin();
+       iter != result->outgoing_messages.end(); ++iter) {
     const mcs_proto::DataMessageStanza* data_message =
-        reinterpret_cast<mcs_proto::DataMessageStanza*>(iter->second);
+        reinterpret_cast<mcs_proto::DataMessageStanza*>(iter->second.get());
     DCHECK(!data_message->from().empty());
     if (app_message_counts_.count(data_message->from()) == 0)
       app_message_counts_[data_message->from()] = 1;
     else
       app_message_counts_[data_message->from()]++;
     if (app_message_counts_[data_message->from()] == kMessagesPerAppLimit)
       num_throttled_apps++;
   }
   UMA_HISTOGRAM_COUNTS("GCM.NumThrottledApps", num_throttled_apps);
-  callback.Run(result);
+  callback.Run(result.Pass());
 }
 
 void GCMStoreImpl::AddOutgoingMessageContinuation(
     const UpdateCallback& callback,
     const std::string& app_id,
     bool success) {
   if (!success) {
     DCHECK(app_message_counts_[app_id] > 0);
     app_message_counts_[app_id]--;
   }
@@ skipping 12 matching lines @@
            removed_message_counts.begin();
        iter != removed_message_counts.end(); ++iter) {
     DCHECK_NE(app_message_counts_.count(iter->first), 0U);
     app_message_counts_[iter->first] -= iter->second;
     DCHECK_GE(app_message_counts_[iter->first], 0);
   }
   callback.Run(true);
 }
 
 }  // namespace gcm