[GCM] Fix memory leaks

Fixes bug where we forgot to clear a ReliablePacketInfo in MCSClient.
Makes GCMStore explicitly pass ownership of the outgoing message memory it
allocates.

BUG=337560

Review URL: https://codereview.chromium.org/147193003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247108 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 142 insertions, 156 deletions

diff --git a/google_apis/gcm/engine/gcm_store.h b/google_apis/gcm/engine/gcm_store.h
index d26ca18..ed97949 100644
--- a/google_apis/gcm/engine/gcm_store.h
+++ b/google_apis/gcm/engine/gcm_store.h
@@ -11,8 +11,11 @@
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "google_apis/gcm/base/gcm_export.h"
+#include "google_apis/gcm/protocol/mcs.pb.h"
 
 namespace google {
 namespace protobuf {
@@ -28,6 +31,10 @@ class MCSMessage;
 // as well as store device and user checkin information.
 class GCM_EXPORT GCMStore {
  public:
+  // Map of message id to message data for outgoing messages.
+  typedef std::map<std::string, linked_ptr<google::protobuf::MessageLite> >
+      OutgoingMessageMap;
+
   // Part of load results storing user serial number mapping related values.
   struct GCM_EXPORT SerialNumberMappings {
     SerialNumberMappings();
@@ -46,13 +53,12 @@ class GCM_EXPORT GCMStore {
     uint64 device_android_id;
     uint64 device_security_token;
     std::vector<std::string> incoming_messages;
-    std::map<std::string, google::protobuf::MessageLite*> outgoing_messages;
+    OutgoingMessageMap outgoing_messages;
     SerialNumberMappings serial_number_mappings;
   };
 
   typedef std::vector<std::string> PersistentIdList;
-  // Note: callee receives ownership of |outgoing_messages|' values.
-  typedef base::Callback<void(const LoadResult& result)> LoadCallback;
+  typedef base::Callback<void(scoped_ptr<LoadResult> result)> LoadCallback;
   typedef base::Callback<void(bool success)> UpdateCallback;
 
   GCMStore();
diff --git a/google_apis/gcm/engine/gcm_store_impl.cc b/google_apis/gcm/engine/gcm_store_impl.cc
index 78c78ff..daf7d36 100644
--- a/google_apis/gcm/engine/gcm_store_impl.cc
+++ b/google_apis/gcm/engine/gcm_store_impl.cc
@@ -124,8 +124,7 @@ class GCMStoreImpl::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);
@@ -144,10 +143,12 @@ GCMStoreImpl::Backend::Backend(
 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;
   }
 
@@ -160,51 +161,55 @@ void GCMStoreImpl::Backend::Load(const LoadCallback& callback) {
   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;
 }
 
@@ -522,7 +527,7 @@ bool GCMStoreImpl::Backend::LoadIncomingMessages(
 }
 
 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;
 
@@ -547,7 +552,7 @@ bool GCMStoreImpl::Backend::LoadOutgoingMessages(
     }
     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;
@@ -763,17 +768,17 @@ void GCMStoreImpl::RemoveUserSerialNumber(const std::string& username,
 }
 
 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;
@@ -783,7 +788,7 @@ void GCMStoreImpl::LoadContinuation(const LoadCallback& callback,
       num_throttled_apps++;
   }
   UMA_HISTOGRAM_COUNTS("GCM.NumThrottledApps", num_throttled_apps);
-  callback.Run(result);
+  callback.Run(result.Pass());
 }
 
 void GCMStoreImpl::AddOutgoingMessageContinuation(
diff --git a/google_apis/gcm/engine/gcm_store_impl.h b/google_apis/gcm/engine/gcm_store_impl.h
index 8c1e08c..621bfe1 100644
--- a/google_apis/gcm/engine/gcm_store_impl.h
+++ b/google_apis/gcm/engine/gcm_store_impl.h
@@ -74,7 +74,7 @@ class GCM_EXPORT GCMStoreImpl : public GCMStore {
 
   // Continuation to update the per-app message counts after a load.
   void LoadContinuation(const LoadCallback& callback,
-                        const LoadResult& result);
+                        scoped_ptr<LoadResult> result);
 
   // Continuation to update the per-app message counts when adding messages.
   // In particular, if a message fails to add, the message count is decremented.
diff --git a/google_apis/gcm/engine/gcm_store_impl_unittest.cc b/google_apis/gcm/engine/gcm_store_impl_unittest.cc
index d504082..4beb0ae 100644
--- a/google_apis/gcm/engine/gcm_store_impl_unittest.cc
+++ b/google_apis/gcm/engine/gcm_store_impl_unittest.cc
@@ -49,8 +49,8 @@ class GCMStoreImplTest : public testing::Test {
 
   void PumpLoop();
 
-  void LoadCallback(GCMStore::LoadResult* result_dst,
-                    const GCMStore::LoadResult& result);
+  void LoadCallback(scoped_ptr<GCMStore::LoadResult>* result_dst,
+                    scoped_ptr<GCMStore::LoadResult> result);
   void UpdateCallback(bool success);
 
  protected:
@@ -81,10 +81,11 @@ std::string GCMStoreImplTest::GetNextPersistentId() {
 
 void GCMStoreImplTest::PumpLoop() { message_loop_.RunUntilIdle(); }
 
-void GCMStoreImplTest::LoadCallback(GCMStore::LoadResult* result_dst,
-                                    const GCMStore::LoadResult& result) {
-  ASSERT_TRUE(result.success);
-  *result_dst = result;
+void GCMStoreImplTest::LoadCallback(
+    scoped_ptr<GCMStore::LoadResult>* result_dst,
+    scoped_ptr<GCMStore::LoadResult> result) {
+  ASSERT_TRUE(result->success);
+  *result_dst = result.Pass();
   run_loop_->Quit();
   run_loop_.reset(new base::RunLoop());
 }
@@ -96,22 +97,22 @@ void GCMStoreImplTest::UpdateCallback(bool success) {
 // Verify creating a new database and loading it.
 TEST_F(GCMStoreImplTest, LoadNew) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  EXPECT_EQ(0U, load_result.device_android_id);
-  EXPECT_EQ(0U, load_result.device_security_token);
-  EXPECT_TRUE(load_result.incoming_messages.empty());
-  EXPECT_TRUE(load_result.outgoing_messages.empty());
-  EXPECT_EQ(1LL, load_result.serial_number_mappings.next_serial_number);
-  EXPECT_TRUE(load_result.serial_number_mappings.user_serial_numbers.empty());
+  EXPECT_EQ(0U, load_result->device_android_id);
+  EXPECT_EQ(0U, load_result->device_security_token);
+  EXPECT_TRUE(load_result->incoming_messages.empty());
+  EXPECT_TRUE(load_result->outgoing_messages.empty());
+  EXPECT_EQ(1LL, load_result->serial_number_mappings.next_serial_number);
+  EXPECT_TRUE(load_result->serial_number_mappings.user_serial_numbers.empty());
 }
 
 TEST_F(GCMStoreImplTest, DeviceCredentials) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -127,15 +128,15 @@ TEST_F(GCMStoreImplTest, DeviceCredentials) {
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_EQ(kDeviceId, load_result.device_android_id);
-  ASSERT_EQ(kDeviceToken, load_result.device_security_token);
+  ASSERT_EQ(kDeviceId, load_result->device_android_id);
+  ASSERT_EQ(kDeviceToken, load_result->device_security_token);
 }
 
 // Verify saving some incoming messages, reopening the directory, and then
 // removing those incoming messages.
 TEST_F(GCMStoreImplTest, IncomingMessages) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -154,8 +155,8 @@ TEST_F(GCMStoreImplTest, IncomingMessages) {
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_EQ(persistent_ids, load_result.incoming_messages);
-  ASSERT_TRUE(load_result.outgoing_messages.empty());
+  ASSERT_EQ(persistent_ids, load_result->incoming_messages);
+  ASSERT_TRUE(load_result->outgoing_messages.empty());
 
   gcm_store->RemoveIncomingMessages(
       persistent_ids,
@@ -163,26 +164,20 @@ TEST_F(GCMStoreImplTest, IncomingMessages) {
   PumpLoop();
 
   gcm_store = BuildGCMStore().Pass();
-  load_result.incoming_messages.clear();
+  load_result->incoming_messages.clear();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_TRUE(load_result.incoming_messages.empty());
-  ASSERT_TRUE(load_result.outgoing_messages.empty());
+  ASSERT_TRUE(load_result->incoming_messages.empty());
+  ASSERT_TRUE(load_result->outgoing_messages.empty());
 }
 
 // Verify saving some outgoing messages, reopening the directory, and then
 // removing those outgoing messages.
-// Fails on linux_asan crbug.com/337560
-#if !defined(OS_POSIX)
-#define MAYBE_OutgoingMessages OutgoingMessages
-#else
-#define MAYBE_OutgoingMessages DISABLED_OutgoingMessages
-#endif
-TEST_F(GCMStoreImplTest, MAYBE_OutgoingMessages) {
+TEST_F(GCMStoreImplTest, OutgoingMessages) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -206,14 +201,14 @@ TEST_F(GCMStoreImplTest, MAYBE_OutgoingMessages) {
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_TRUE(load_result.incoming_messages.empty());
-  ASSERT_EQ(load_result.outgoing_messages.size(), persistent_ids.size());
+  ASSERT_TRUE(load_result->incoming_messages.empty());
+  ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size());
   for (int i = 0; i < kNumPersistentIds; ++i) {
     std::string id = persistent_ids[i];
-    ASSERT_TRUE(load_result.outgoing_messages[id]);
+    ASSERT_TRUE(load_result->outgoing_messages[id].get());
     const mcs_proto::DataMessageStanza* message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
-            load_result.outgoing_messages[id]);
+            load_result->outgoing_messages[id].get());
     ASSERT_EQ(message->from(), kAppName + id);
     ASSERT_EQ(message->category(), kCategoryName + id);
   }
@@ -224,25 +219,19 @@ TEST_F(GCMStoreImplTest, MAYBE_OutgoingMessages) {
   PumpLoop();
 
   gcm_store = BuildGCMStore().Pass();
-  load_result.outgoing_messages.clear();
+  load_result->outgoing_messages.clear();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_TRUE(load_result.incoming_messages.empty());
-  ASSERT_TRUE(load_result.outgoing_messages.empty());
+  ASSERT_TRUE(load_result->incoming_messages.empty());
+  ASSERT_TRUE(load_result->outgoing_messages.empty());
 }
 
 // Verify incoming and outgoing messages don't conflict.
-// Fails on linux_asan crbug.com/337560
-#if !defined(OS_POSIX)
-#define MAYBE_IncomingAndOutgoingMessages IncomingAndOutgoingMessages
-#else
-#define MAYBE_IncomingAndOutgoingMessages DISABLED_IncomingAndOutgoingMessages
-#endif
-TEST_F(GCMStoreImplTest, MAYBE_IncomingAndOutgoingMessages) {
+TEST_F(GCMStoreImplTest, IncomingAndOutgoingMessages) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -271,14 +260,14 @@ TEST_F(GCMStoreImplTest, MAYBE_IncomingAndOutgoingMessages) {
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_EQ(persistent_ids, load_result.incoming_messages);
-  ASSERT_EQ(load_result.outgoing_messages.size(), persistent_ids.size());
+  ASSERT_EQ(persistent_ids, load_result->incoming_messages);
+  ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size());
   for (int i = 0; i < kNumPersistentIds; ++i) {
     std::string id = persistent_ids[i];
-    ASSERT_TRUE(load_result.outgoing_messages[id]);
+    ASSERT_TRUE(load_result->outgoing_messages[id].get());
     const mcs_proto::DataMessageStanza* message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
-            load_result.outgoing_messages[id]);
+            load_result->outgoing_messages[id].get());
     ASSERT_EQ(message->from(), kAppName + id);
     ASSERT_EQ(message->category(), kCategoryName + id);
   }
@@ -293,21 +282,21 @@ TEST_F(GCMStoreImplTest, MAYBE_IncomingAndOutgoingMessages) {
   PumpLoop();
 
   gcm_store = BuildGCMStore().Pass();
-  load_result.incoming_messages.clear();
-  load_result.outgoing_messages.clear();
+  load_result->incoming_messages.clear();
+  load_result->outgoing_messages.clear();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_TRUE(load_result.incoming_messages.empty());
-  ASSERT_TRUE(load_result.outgoing_messages.empty());
+  ASSERT_TRUE(load_result->incoming_messages.empty());
+  ASSERT_TRUE(load_result->outgoing_messages.empty());
 }
 
 // Verify that the next serial number of persisted properly.
 TEST_F(GCMStoreImplTest, NextSerialNumber) {
   const int64 kNextSerialNumber = 77LL;
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -323,13 +312,13 @@ TEST_F(GCMStoreImplTest, NextSerialNumber) {
   PumpLoop();
 
   EXPECT_EQ(kNextSerialNumber,
-            load_result.serial_number_mappings.next_serial_number);
+            load_result->serial_number_mappings.next_serial_number);
 }
 
 // Verify that user serial number mappings are persisted properly.
 TEST_F(GCMStoreImplTest, UserSerialNumberMappings) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
@@ -354,30 +343,24 @@ TEST_F(GCMStoreImplTest, UserSerialNumberMappings) {
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
-  ASSERT_EQ(2u, load_result.serial_number_mappings.user_serial_numbers.size());
+  ASSERT_EQ(2u, load_result->serial_number_mappings.user_serial_numbers.size());
   ASSERT_NE(
-      load_result.serial_number_mappings.user_serial_numbers.end(),
-      load_result.serial_number_mappings.user_serial_numbers.find(username1));
+      load_result->serial_number_mappings.user_serial_numbers.end(),
+      load_result->serial_number_mappings.user_serial_numbers.find(username1));
   EXPECT_EQ(serial_number1,
-            load_result.serial_number_mappings.user_serial_numbers[username1]);
+            load_result->serial_number_mappings.user_serial_numbers[username1]);
   ASSERT_NE(
-      load_result.serial_number_mappings.user_serial_numbers.end(),
-      load_result.serial_number_mappings.user_serial_numbers.find(username2));
+      load_result->serial_number_mappings.user_serial_numbers.end(),
+      load_result->serial_number_mappings.user_serial_numbers.find(username2));
   EXPECT_EQ(serial_number2,
-            load_result.serial_number_mappings.user_serial_numbers[username2]);
+            load_result->serial_number_mappings.user_serial_numbers[username2]);
 }
 
 // Test that per-app message limits are enforced, persisted across restarts,
 // and updated as messages are removed.
-// Fails on linux_asan crbug.com/337560
-#if !defined(OS_POSIX)
-#define MAYBE_PerAppMessageLimits PerAppMessageLimits
-#else
-#define MAYBE_PerAppMessageLimits DISABLED_PerAppMessageLimits
-#endif
-TEST_F(GCMStoreImplTest, MAYBE_PerAppMessageLimits) {
+TEST_F(GCMStoreImplTest, PerAppMessageLimits) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback,
                              base::Unretained(this),
                              &load_result));
@@ -456,7 +439,7 @@ TEST_F(GCMStoreImplTest, MAYBE_PerAppMessageLimits) {
 // result in decrementing the counts.
 TEST_F(GCMStoreImplTest, AddMessageAfterDestroy) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
-  GCMStore::LoadResult load_result;
+  scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback,
                              base::Unretained(this),
                              &load_result));
diff --git a/google_apis/gcm/engine/mcs_client.cc b/google_apis/gcm/engine/mcs_client.cc
index 41bb4d0..5e6490a 100644
--- a/google_apis/gcm/engine/mcs_client.cc
+++ b/google_apis/gcm/engine/mcs_client.cc
@@ -109,7 +109,7 @@ 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;
@@ -128,8 +128,8 @@ void MCSClient::Initialize(
 
   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.";
@@ -141,19 +141,19 @@ void MCSClient::Initialize(
   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.";
@@ -166,11 +166,10 @@ void MCSClient::Initialize(
     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()) {
@@ -182,7 +181,7 @@ void MCSClient::Initialize(
 
   // 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();
@@ -222,7 +221,7 @@ void MCSClient::SendMessage(const MCSMessage& message) {
     return;
   }
 
-  ReliablePacketInfo* packet_info = new ReliablePacketInfo();
+  scoped_ptr<ReliablePacketInfo> packet_info(new ReliablePacketInfo());
   packet_info->tag = message.tag();
   packet_info->protobuf = message.CloneProtobuf();
 
@@ -247,7 +246,7 @@ void MCSClient::SendMessage(const MCSMessage& 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();
 }
 
diff --git a/google_apis/gcm/engine/mcs_client.h b/google_apis/gcm/engine/mcs_client.h
index 38ba298..1b27950 100644
--- a/google_apis/gcm/engine/mcs_client.h
+++ b/google_apis/gcm/engine/mcs_client.h
@@ -98,7 +98,7 @@ class GCM_EXPORT MCSClient {
   void Initialize(const ErrorCallback& initialization_callback,
                   const OnMessageReceivedCallback& message_received_callback,
                   const OnMessageSentCallback& message_sent_callback,
-                  const GCMStore::LoadResult& load_result);
+                  scoped_ptr<GCMStore::LoadResult> load_result);
 
   // Logs the client into the server. Client must be initialized.
   // |android_id| and |security_token| are optional if this is not a new
diff --git a/google_apis/gcm/engine/mcs_client_unittest.cc b/google_apis/gcm/engine/mcs_client_unittest.cc
index 587edfa..7ba5904 100644
--- a/google_apis/gcm/engine/mcs_client_unittest.cc
+++ b/google_apis/gcm/engine/mcs_client_unittest.cc
@@ -294,15 +294,7 @@ TEST_F(MCSClientTest, SendMessageNoRMQ) {
 
 // Send a message without RMQ support while disconnected. Message send should
 // fail immediately, invoking callback.
-// Fails on linux_asan crbug.com/337560
-#if !defined(OS_POSIX)
-#define MAYBE_SendMessageNoRMQWhileDisconnected \
-    SendMessageNoRMQWhileDisconnected
-#else
-#define MAYBE_SendMessageNoRMQWhileDisconnected \
-    DISABLED_SendMessageNoRMQWhileDisconnected
-#endif
-TEST_F(MCSClientTest, MAYBE_SendMessageNoRMQWhileDisconnected) {
+TEST_F(MCSClientTest, SendMessageNoRMQWhileDisconnected) {
   BuildMCSClient();
   InitializeClient();
 
diff --git a/google_apis/gcm/engine/user_list_unittest.cc b/google_apis/gcm/engine/user_list_unittest.cc
index e07f68d..476f317 100644
--- a/google_apis/gcm/engine/user_list_unittest.cc
+++ b/google_apis/gcm/engine/user_list_unittest.cc
@@ -72,7 +72,7 @@ class UserListTest : public testing::Test {
 
   void UpdateCallback(bool success);
 
-  void Initialize(UserList* user_list, const GCMStore::LoadResult& result);
+  void Initialize(UserList* user_list, scoped_ptr<GCMStore::LoadResult> result);
 
   void ResetLoop();
 
@@ -116,9 +116,9 @@ scoped_ptr<UserList> UserListTest::BuildUserList() {
 }
 
 void UserListTest::Initialize(UserList* user_list,
-                              const GCMStore::LoadResult& result) {
-  ASSERT_TRUE(result.success);
-  user_list->Initialize(result.serial_number_mappings);
+                              scoped_ptr<GCMStore::LoadResult> result) {
+  ASSERT_TRUE(result->success);
+  user_list->Initialize(result->serial_number_mappings);
   ResetLoop();
 }
 
diff --git a/google_apis/gcm/gcm_client_impl.cc b/google_apis/gcm/gcm_client_impl.cc
index e03211f..6ab61af 100644
--- a/google_apis/gcm/gcm_client_impl.cc
+++ b/google_apis/gcm/gcm_client_impl.cc
@@ -61,19 +61,19 @@ void GCMClientImpl::Initialize(
   state_ = LOADING;
 }
 
-void GCMClientImpl::OnLoadCompleted(const GCMStore::LoadResult& result) {
+void GCMClientImpl::OnLoadCompleted(scoped_ptr<GCMStore::LoadResult> result) {
   DCHECK_EQ(LOADING, state_);
 
-  if (!result.success) {
+  if (!result->success) {
     ResetState();
     return;
   }
 
-  user_list_->Initialize(result.serial_number_mappings);
+  user_list_->Initialize(result->serial_number_mappings);
 
-  device_checkin_info_.android_id = result.device_android_id;
-  device_checkin_info_.secret = result.device_security_token;
-  InitializeMCSClient(result);
+  device_checkin_info_.android_id = result->device_android_id;
+  device_checkin_info_.secret = result->device_security_token;
+  InitializeMCSClient(result.Pass());
   if (!device_checkin_info_.IsValid()) {
     device_checkin_info_.Reset();
     state_ = INITIAL_DEVICE_CHECKIN;
@@ -84,13 +84,14 @@ void GCMClientImpl::OnLoadCompleted(const GCMStore::LoadResult& result) {
   }
 }
 
-void GCMClientImpl::InitializeMCSClient(const GCMStore::LoadResult& result) {
+void GCMClientImpl::InitializeMCSClient(
+    scoped_ptr<GCMStore::LoadResult> result) {
   mcs_client_->Initialize(
       base::Bind(&GCMClientImpl::OnMCSError, base::Unretained(this)),
       base::Bind(&GCMClientImpl::OnMessageReceivedFromMCS,
                  base::Unretained(this)),
       base::Bind(&GCMClientImpl::OnMessageSentToMCS, base::Unretained(this)),
-      result);
+      result.Pass());
 }
 
 void GCMClientImpl::OnFirstTimeDeviceCheckinCompleted(
diff --git a/google_apis/gcm/gcm_client_impl.h b/google_apis/gcm/gcm_client_impl.h
index f8c3310..ccaa54d 100644
--- a/google_apis/gcm/gcm_client_impl.h
+++ b/google_apis/gcm/gcm_client_impl.h
@@ -102,9 +102,9 @@ class GCM_EXPORT GCMClientImpl : public GCMClient {
 
   // Runs after GCM Store load is done to trigger continuation of the
   // initialization.
-  void OnLoadCompleted(const GCMStore::LoadResult& result);
+  void OnLoadCompleted(scoped_ptr<GCMStore::LoadResult> result);
   // Initializes mcs_client_, which handles the connection to MCS.
-  void InitializeMCSClient(const GCMStore::LoadResult& result);
+  void InitializeMCSClient(scoped_ptr<GCMStore::LoadResult> result);
   // Complets the first time device checkin.
   void OnFirstTimeDeviceCheckinCompleted(const CheckinInfo& checkin_info);
   // Starts a login on mcs_client_.
diff --git a/google_apis/gcm/tools/mcs_probe.cc b/google_apis/gcm/tools/mcs_probe.cc
index f2528ef..7dce593 100644
--- a/google_apis/gcm/tools/mcs_probe.cc
+++ b/google_apis/gcm/tools/mcs_probe.cc
@@ -181,7 +181,7 @@ class MCSProbe {
   void InitializeNetworkState();
   void BuildNetworkSession();
 
-  void LoadCallback(const GCMStore::LoadResult& load_result);
+  void LoadCallback(scoped_ptr<GCMStore::LoadResult> load_result);
   void ErrorCallback();
   void OnCheckInCompleted(uint64 android_id, uint64 secret);
 
@@ -280,15 +280,15 @@ void MCSProbe::Start() {
   run_loop_->Run();
 }
 
-void MCSProbe::LoadCallback(const GCMStore::LoadResult& load_result) {
-  DCHECK(load_result.success);
-  android_id_ = load_result.device_android_id;
-  secret_ = load_result.device_security_token;
+void MCSProbe::LoadCallback(scoped_ptr<GCMStore::LoadResult> load_result) {
+  DCHECK(load_result->success);
+  android_id_ = load_result->device_android_id;
+  secret_ = load_result->device_security_token;
   mcs_client_->Initialize(
       base::Bind(&MCSProbe::ErrorCallback, base::Unretained(this)),
       base::Bind(&MessageReceivedCallback),
       base::Bind(&MessageSentCallback),
-      load_result);
+      load_result.Pass());
 
   if (!android_id_ || !secret_) {
     CheckIn();