Do not create GCM store if it is not needed

google_apis/gcm/engine/gcm_store.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_
 #define GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 11 matching lines @@
 #include "google_apis/gcm/engine/account_mapping.h"
 
 namespace gcm {
 
 class MCSMessage;
 
 // A GCM data store interface. GCM Store will handle persistence portion of RMQ,
 // as well as store device and user checkin information.
 class GCM_EXPORT GCMStore {
  public:
+  enum StoreOpenMode {
+    DO_NOT_CREATE_NEW_STORE,
+    CREATE_NEW_STORE_IF_NOT_EXISTS

[Nicolas Zea, 2015/06/15 17:58:37]

nit: CREATE_IF_MISSING (which is the variable you use elsewhere) is I think a
clearer enum

Similarly you can shorten DO_NOT_CREATE_NEW_STORE to DO_NOT_CREATE

[jianli, 2015/06/15 20:50:23]

Done.

+  };
+
   // Map of message id to message data for outgoing messages.
   typedef std::map<std::string, linked_ptr<google::protobuf::MessageLite> >
       OutgoingMessageMap;
 
   // List of account mappings.
   typedef std::vector<AccountMapping> AccountMappings;
 
   // Container for Load(..) results.
   struct GCM_EXPORT LoadResult {
     LoadResult();
     ~LoadResult();
 
     void Reset();
 
     bool success;
+    bool store_does_not_exist;
     uint64 device_android_id;
     uint64 device_security_token;
     std::map<std::string, std::string> registrations;
     std::vector<std::string> incoming_messages;
     OutgoingMessageMap outgoing_messages;
     std::map<std::string, std::string> gservices_settings;
     std::string gservices_digest;
     base::Time last_checkin_time;
     std::set<std::string> last_checkin_accounts;
     AccountMappings account_mappings;
     base::Time last_token_fetch_time;
     std::map<std::string, int> heartbeat_intervals;
     std::map<std::string, std::string> instance_id_data;
   };
 
   typedef std::vector<std::string> PersistentIdList;
   typedef base::Callback<void(scoped_ptr<LoadResult> result)> LoadCallback;
   typedef base::Callback<void(bool success)> UpdateCallback;
 
   GCMStore();
   virtual ~GCMStore();
 
   // Load the data from persistent store and pass the initial state back to
   // caller.
-  virtual void Load(const LoadCallback& callback) = 0;
+  virtual void Load(StoreOpenMode open_mode, const LoadCallback& callback) = 0;
 
   // Close the persistent store.
   virtual void Close() = 0;
 
   // Clears the GCM store of all data.
   virtual void Destroy(const UpdateCallback& callback) = 0;
 
   // Sets this device's messaging credentials.
   virtual void SetDeviceCredentials(uint64 device_android_id,
                                     uint64 device_security_token,
@@ skipping 70 matching lines @@
   virtual void RemoveInstanceIDData(const std::string& app_id,
                                     const UpdateCallback& callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GCMStore);
 };
 
 }  // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_