AU: Manual proxy support

update_attempter.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_UPDATE_ATTEMPTER_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_UPDATE_ATTEMPTER_H__
 
 #include <time.h>
 
 #include <tr1/memory>
 #include <string>
 #include <vector>
 
 #include <base/time.h>
 #include <glib.h>
 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
 
 #include "update_engine/action_processor.h"
+#include "update_engine/chrome_proxy_resolver.h"
 #include "update_engine/download_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
+#include "update_engine/proxy_resolver.h"
 
 class MetricsLibraryInterface;
 struct UpdateEngineService;
 
 namespace chromeos_update_engine {
 
 class UpdateCheckScheduler;
 
 extern const char* kUpdateCompletedMarker;
 
 enum UpdateStatus {
   UPDATE_STATUS_IDLE = 0,
   UPDATE_STATUS_CHECKING_FOR_UPDATE,
   UPDATE_STATUS_UPDATE_AVAILABLE,
   UPDATE_STATUS_DOWNLOADING,
   UPDATE_STATUS_VERIFYING,
   UPDATE_STATUS_FINALIZING,
   UPDATE_STATUS_UPDATED_NEED_REBOOT,
   UPDATE_STATUS_REPORTING_ERROR_EVENT,
 };
 
 const char* UpdateStatusToString(UpdateStatus status);
 
 class UpdateAttempter : public ActionProcessorDelegate,
                         public DownloadActionDelegate {
  public:
   static const int kMaxDeltaUpdateFailures;
 
-  UpdateAttempter(PrefsInterface* prefs, MetricsLibraryInterface* metrics_lib);
+  UpdateAttempter(PrefsInterface* prefs,
+                  MetricsLibraryInterface* metrics_lib,
+                  DbusGlibInterface* dbus_iface);
   virtual ~UpdateAttempter();
 
   // Checks for update and, if a newer version is available, attempts
   // to update the system. Non-empty |in_app_version| or
   // |in_update_url| prevents automatic detection of the parameter.
+  // If force_obey_proxies is true, the update will likely respect Chrome's

[petkov, 2010/11/19 05:37:15]

|force_obey_proxies| or maybe just |obey_proxies| given that it's not really
forced (given that we _may_ obey them).

[adlr, 2010/11/20 02:52:29]

Done.

+  // proxy setting. For security reasons, we may still not honor them.
   virtual void Update(const std::string& app_version,
-                      const std::string& omaha_url);
+                      const std::string& omaha_url,
+                      bool force_obey_proxies);
 
   // ActionProcessorDelegate methods:
   void ProcessingDone(const ActionProcessor* processor, ActionExitCode code);
   void ProcessingStopped(const ActionProcessor* processor);
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
                        ActionExitCode code);
 
   // Stop updating. An attempt will be made to record status to the disk
   // so that updates can be resumed later.
@@ skipping 78 matching lines @@
   static gboolean StaticManagePriorityCallback(gpointer data);
   bool ManagePriorityCallback();
 
   // Checks if a full update is needed and forces it by updating the Omaha
   // request params.
   void DisableDeltaUpdateIfNeeded();
 
   // If this was a delta update attempt that failed, count it so that a full
   // update can be tried when needed.
   void MarkDeltaUpdateFailure();
+  
+  ProxyResolver* GetProxyResolver() {
+    return obeying_proxies_ ?
+        reinterpret_cast<ProxyResolver*>(&chrome_proxy_resolver_) :
+        reinterpret_cast<ProxyResolver*>(&direct_proxy_resolver_);
+  }
 
   // Last status notification timestamp used for throttling. Use monotonic
   // TimeTicks to ensure that notifications are sent even if the system clock is
   // set back in the middle of an update.
   base::TimeTicks last_notify_time_;
 
   std::vector<std::tr1::shared_ptr<AbstractAction> > actions_;
   scoped_ptr<ActionProcessor> processor_;
 
   // If non-null, this UpdateAttempter will send status updates over this
@@ skipping 35 matching lines @@
   UpdateStatus status_;
   double download_progress_;
   int64_t last_checked_time_;
   std::string new_version_;
   int64_t new_size_;
   bool is_full_update_;
 
   // Device paramaters common to all Omaha requests.
   OmahaRequestDeviceParams omaha_request_params_;
 
+  // Number of consecutive manual update checks we've had where we obeyed
+  // Chrome's proxy settings.
+  int proxy_manual_checks_;
+
+  // If true, this update cycle we are obeying proxies
+  bool obeying_proxies_;
+
+  // Our two proxy resolvers
+  DirectProxyResolver direct_proxy_resolver_;
+  ChromeProxyResolver chrome_proxy_resolver_;
+
   DISALLOW_COPY_AND_ASSIGN(UpdateAttempter);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_UPDATE_ATTEMPTER_H__