Don't send machine and user ID to Omaha anymore. Send a/r pings instead.

omaha_request_action.h

 // Copyright (c) 2010 The Chromium OS 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_REQUEST_ACTION_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_REQUEST_ACTION_H__
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
@@ skipping 67 matching lines @@
         error_code(in_error_code) {}
 
   Type type;
   Result result;
   ActionExitCode error_code;
 };
 
 class NoneType;
 class OmahaRequestAction;
 struct OmahaRequestParams;
+class PrefsInterface;
 
 template<>
 class ActionTraits<OmahaRequestAction> {
  public:
   // Takes parameters on the input pipe.
   typedef NoneType InputObjectType;
   // On UpdateCheck success, puts the Omaha response on output. Event
   // requests do not have an output pipe.
   typedef OmahaResponse OutputObjectType;
 };
 
 class OmahaRequestAction : public Action<OmahaRequestAction>,
                            public HttpFetcherDelegate {
  public:
+  static const int kNeverPinged = -1;
+  static const int kPingTimeJump = -2;
+
   // The ctor takes in all the parameters that will be used for making
   // the request to Omaha. For some of them we have constants that
   // should be used.
   //
   // Takes ownership of the passed in HttpFetcher. Useful for testing.
   //
   // Takes ownership of the passed in OmahaEvent. If |event| is NULL,
   // this is an UpdateCheck request, otherwise it's an Event request.
   // Event requests always succeed.
   //
   // A good calling pattern is:
   // OmahaRequestAction(..., new OmahaEvent(...), new WhateverHttpFetcher);
   // or
   // OmahaRequestAction(..., NULL, new WhateverHttpFetcher);
-  OmahaRequestAction(const OmahaRequestParams& params,
+  OmahaRequestAction(PrefsInterface* prefs,
+                     const OmahaRequestParams& params,
                      OmahaEvent* event,
                      HttpFetcher* http_fetcher);
   virtual ~OmahaRequestAction();
   typedef ActionTraits<OmahaRequestAction>::InputObjectType InputObjectType;
   typedef ActionTraits<OmahaRequestAction>::OutputObjectType OutputObjectType;
   void PerformAction();
   void TerminateProcessing();
 
   // Debugging/logging
   static std::string StaticType() { return "OmahaRequestAction"; }
   std::string Type() const { return StaticType(); }
 
   // Delegate methods (see http_fetcher.h)
   virtual void ReceivedBytes(HttpFetcher *fetcher,
                              const char* bytes, int length);
   virtual void TransferComplete(HttpFetcher *fetcher, bool successful);
 
   // Returns true if this is an Event request, false if it's an UpdateCheck.
   bool IsEvent() const { return event_.get() != NULL; }
 
  private:
+  // If this is an update check request, initializes
+  // |ping_active_days_| and |ping_roll_call_days_| to values that may
+  // be sent as pings to Omaha.
+  void InitPingDays();
+
+  // Based on the perstitent preference store values, calculates the

[Carl Nygaard, 2010/07/29 21:02:53]

perstitent -> persistent

+  // number of days since the last ping sent for |key|.
+  int CalculatePingDays(const std::string& key);
+
+  // Access to the preferences store.
+  PrefsInterface* prefs_;
+
   // These are data that are passed in the request to the Omaha server.
   const OmahaRequestParams& params_;
 
   // Pointer to the OmahaEvent info. This is an UpdateCheck request if NULL.
   scoped_ptr<OmahaEvent> event_;
 
   // pointer to the HttpFetcher that does the http work
   scoped_ptr<HttpFetcher> http_fetcher_;
 
   // Stores the response from the omaha server
   std::vector<char> response_buffer_;
 
+  // Initialized by InitPingDays to values that may be sent to Omaha
+  // as part of a ping message. Note that only positive values and -1
+  // are sent to Omaha.
+  int ping_active_days_;
+  int ping_roll_call_days_;
+
   DISALLOW_COPY_AND_ASSIGN(OmahaRequestAction);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_REQUEST_ACTION_H__