AU: Try delta updates first, then full updates

src/platform/update_engine/action.h

 // Copyright (c) 2009 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_ACTION_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_ACTION_H__
 
 #include <stdio.h>
 #include <tr1/memory>
 #include <iostream>
@@ skipping 44 matching lines @@
 // DownloadAction::InputObjectType.
 //
 // Each concrete Action class derives from Action<T>. This means that during
 // template instatiation of Action<T>, T is declared but not defined, which
 // means that T::InputObjectType (and OutputObjectType) is not defined.
 // However, the traits class is constructed in such a way that it will be
 // template instatiated first, so Action<T> *can* find the types it needs by
 // consulting ActionTraits<T>::InputObjectType (and OutputObjectType).
 // This is why the ActionTraits classes are needed.
 
-using std::tr1::shared_ptr;
-
 namespace chromeos_update_engine {
 
 // It is handy to have a non-templated base class of all Actions.
 class AbstractAction {
  public:
   AbstractAction() : processor_(NULL) {}
 
   // Begin performing the action. Since this code is asynchronous, when this
   // method returns, it means only that the action has started, not necessarily
   // completed. However, it's acceptable for this method to perform the
@@ skipping 27 matching lines @@
   // there's any cleanup to do. There is no need to call
   // ActionProcessor::ActionComplete() because the processor knows this
   // action is terminating.
   // Only the ActionProcessor should call this.
   virtual void TerminateProcessing() {};
 
   // These methods are useful for debugging. TODO(adlr): consider using
   // std::type_info for this?
   // Type() returns a string of the Action type. I.e., for DownloadAction,
   // Type() would return "DownloadAction".
-  virtual string Type() const = 0;
+  virtual std::string Type() const = 0;
 
  protected:
   // A weak pointer to the processor that owns this Action.
   ActionProcessor* processor_;
 };
 
 // Forward declare a couple classes we use.
 template<typename T>
 class ActionPipe;
 template<typename T>
 class ActionTraits;
 
 template<typename SubClass>
 class Action : public AbstractAction {
  public:
   virtual ~Action() {
     LOG(INFO) << "Action died";
   }
 
   // Attaches an input pipe to this Action. This is optional; an Action
   // doesn't need to have an input pipe. The input pipe must be of the type
   // of object that this class expects.
   // This is generally called by ActionPipe::Bond()
   void set_in_pipe(
       // this type is a fancy way of saying: a shared_ptr to an
       // ActionPipe<InputObjectType>.
-      const shared_ptr<ActionPipe<
+      const std::tr1::shared_ptr<ActionPipe<
           typename ActionTraits<SubClass>::InputObjectType> >&
           in_pipe) {
     in_pipe_ = in_pipe;
   }
 
   // Attaches an output pipe to this Action. This is optional; an Action
   // doesn't need to have an output pipe. The output pipe must be of the type
   // of object that this class expects.
   // This is generally called by ActionPipe::Bond()
   void set_out_pipe(
       // this type is a fancy way of saying: a shared_ptr to an
       // ActionPipe<OutputObjectType>.
-      const shared_ptr<ActionPipe<
+      const std::tr1::shared_ptr<ActionPipe<
           typename ActionTraits<SubClass>::OutputObjectType> >&
           out_pipe) {
     out_pipe_ = out_pipe;
   }
 
   // Returns true iff there is an associated input pipe. If there's an input
   // pipe, there's an input object, but it may have been constructed with the
   // default ctor if the previous action didn't call SetOutputObject().
   bool HasInputObject() const { return in_pipe_.get(); }
 
@@ skipping 22 matching lines @@
   const typename ActionTraits<SubClass>::OutputObjectType& GetOutputObject() {
     CHECK(HasOutputPipe());
     return out_pipe_->contents();
   }
 
 protected:
   // We use a shared_ptr to the pipe. shared_ptr objects destroy what they
   // point to when the last such shared_ptr object dies. We consider the
   // Actions on either end of a pipe to "own" the pipe. When the last Action
   // of the two dies, the ActionPipe will die, too.
-  shared_ptr<ActionPipe<typename ActionTraits<SubClass>::InputObjectType> >
+  std::tr1::shared_ptr<
+      ActionPipe<typename ActionTraits<SubClass>::InputObjectType> >
       in_pipe_;
-  shared_ptr<ActionPipe<typename ActionTraits<SubClass>::OutputObjectType> >
+  std::tr1::shared_ptr<
+      ActionPipe<typename ActionTraits<SubClass>::OutputObjectType> >
       out_pipe_;
 };
 
 };  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_ACTION_H__