diff --git a/Android.mk b/Android.mk
index d545cd5..4801a49 100644
--- a/Android.mk
+++ b/Android.mk
@@ -26,7 +26,6 @@
 # the system layer.
 local_use_libcros := $(if $(BRILLO_USE_LIBCROS),$(BRILLO_USE_LIBCROS),0)
 local_use_mtd := $(if $(BRILLO_USE_MTD),$(BRILLO_USE_MTD),0)
-local_use_weave := $(if $(BRILLO_USE_WEAVE),$(BRILLO_USE_WEAVE),0)
 
 # IoT devices use Omaha for updates.
 local_use_omaha := $(if $(filter true,$(PRODUCT_IOT)),1,0)
@@ -37,7 +36,6 @@
     -DUSE_LIBCROS=$(local_use_libcros) \
     -DUSE_MTD=$(local_use_mtd) \
     -DUSE_OMAHA=$(local_use_omaha) \
-    -DUSE_WEAVE=$(local_use_weave) \
     -D_FILE_OFFSET_BITS=64 \
     -D_POSIX_C_SOURCE=199309L \
     -Wa,--noexecstack \
@@ -100,11 +98,9 @@
 # The payload application component and common dependencies.
 ue_libpayload_consumer_exported_static_libraries := \
     update_metadata-protos \
-    libxz-host \
+    libxz \
     libbz \
-    libimgpatch \
     libbspatch \
-    libz \
     $(ue_update_metadata_protos_exported_static_libraries)
 ue_libpayload_consumer_exported_shared_libraries := \
     libcrypto \
@@ -260,12 +256,6 @@
     libbrillo-binder \
     libutils
 endif  # local_use_binder == 1
-ifeq ($(local_use_weave),1)
-ue_libupdate_engine_exported_shared_libraries += \
-    libbinderwrapper \
-    libbrillo-binder \
-    libweaved
-endif  # local_use_weave == 1
 
 include $(CLEAR_VARS)
 LOCAL_MODULE := libupdate_engine
@@ -327,8 +317,7 @@
     update_manager/state_factory.cc \
     update_manager/update_manager.cc \
     update_status_utils.cc \
-    utils_android.cc \
-    weave_service_factory.cc
+    utils_android.cc
 ifeq ($(local_use_binder),1)
 LOCAL_AIDL_INCLUDES += $(LOCAL_PATH)/binder_bindings
 LOCAL_SRC_FILES += \
@@ -337,10 +326,6 @@
     binder_service_brillo.cc \
     parcelable_update_engine_status.cc
 endif  # local_use_binder == 1
-ifeq ($(local_use_weave),1)
-LOCAL_SRC_FILES += \
-    weave_service.cc
-endif  # local_use_weave == 1
 ifeq ($(local_use_libcros),1)
 LOCAL_SRC_FILES += \
     chrome_browser_proxy_resolver.cc
@@ -425,9 +410,6 @@
 LOCAL_MODULE_CLASS := EXECUTABLES
 LOCAL_REQUIRED_MODULES := \
     cacerts_google
-ifeq ($(local_use_weave),1)
-LOCAL_REQUIRED_MODULES += updater.json
-endif  # local_use_weave == 1
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_CLANG := true
 LOCAL_CFLAGS := $(ue_common_cflags)
@@ -1029,15 +1011,6 @@
 endif  # local_use_libcros == 1
 include $(BUILD_NATIVE_TEST)
 
-# Weave schema files
-# ========================================================
-include $(CLEAR_VARS)
-LOCAL_MODULE := updater.json
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved/traits
-LOCAL_SRC_FILES := weaved/traits/$(LOCAL_MODULE)
-include $(BUILD_PREBUILT)
-
 # Update payload signing public key.
 # ========================================================
 ifdef BRILLO
diff --git a/binder_service_android.h b/binder_service_android.h
index 3fb38bc..3293c0e 100644
--- a/binder_service_android.h
+++ b/binder_service_android.h
@@ -52,9 +52,6 @@
                         int64_t new_size) override;
   void SendPayloadApplicationComplete(ErrorCode error_code) override;
 
-  // Channel tracking changes are ignored.
-  void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
-
   // android::os::BnUpdateEngine overrides.
   android::binder::Status applyPayload(
       const android::String16& url,
diff --git a/binder_service_brillo.h b/binder_service_brillo.h
index fad0f8c..982c7b1 100644
--- a/binder_service_brillo.h
+++ b/binder_service_brillo.h
@@ -52,8 +52,6 @@
                         const std::string& new_version,
                         int64_t new_size) override;
   void SendPayloadApplicationComplete(ErrorCode error_code) override {}
-  // Channel tracking changes are ignored.
-  void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
 
   // android::brillo::BnUpdateEngine overrides.
   android::binder::Status AttemptUpdate(const android::String16& app_version,
diff --git a/chrome_browser_proxy_resolver.cc b/chrome_browser_proxy_resolver.cc
index 09365c1..12a8328 100644
--- a/chrome_browser_proxy_resolver.cc
+++ b/chrome_browser_proxy_resolver.cc
@@ -16,141 +16,37 @@
 
 #include "update_engine/chrome_browser_proxy_resolver.h"
 
-#include <deque>
-#include <string>
+#include <utility>
 
 #include <base/bind.h>
+#include <base/memory/ptr_util.h>
 #include <base/strings/string_tokenizer.h>
 #include <base/strings/string_util.h>
 
-#include "update_engine/common/utils.h"
+#include "network_proxy/dbus-proxies.h"
 
 namespace chromeos_update_engine {
 
 using base::StringTokenizer;
-using base::TimeDelta;
-using brillo::MessageLoop;
 using std::deque;
 using std::string;
 
-const char kLibCrosServiceName[] = "org.chromium.LibCrosService";
-const char kLibCrosProxyResolveName[] = "ProxyResolved";
-const char kLibCrosProxyResolveSignalInterface[] =
-    "org.chromium.UpdateEngineLibcrosProxyResolvedInterface";
-
 namespace {
 
-const int kTimeout = 5;  // seconds
+// Timeout for D-Bus calls in milliseconds.
+constexpr int kTimeoutMs = 5000;
 
 }  // namespace
 
 ChromeBrowserProxyResolver::ChromeBrowserProxyResolver(
-    LibCrosProxy* libcros_proxy)
-    : libcros_proxy_(libcros_proxy), timeout_(kTimeout) {}
+    org::chromium::NetworkProxyServiceInterfaceProxyInterface* dbus_proxy)
+    : dbus_proxy_(dbus_proxy),
+      next_request_id_(kProxyRequestIdNull + 1),
+      weak_ptr_factory_(this) {}
 
-bool ChromeBrowserProxyResolver::Init() {
-  libcros_proxy_->ue_proxy_resolved_interface()
-      ->RegisterProxyResolvedSignalHandler(
-          base::Bind(&ChromeBrowserProxyResolver::OnProxyResolvedSignal,
-                     base::Unretained(this)),
-          base::Bind(&ChromeBrowserProxyResolver::OnSignalConnected,
-                     base::Unretained(this)));
-  return true;
-}
+ChromeBrowserProxyResolver::~ChromeBrowserProxyResolver() = default;
 
-ChromeBrowserProxyResolver::~ChromeBrowserProxyResolver() {
-  // Kill outstanding timers.
-  for (const auto& it : callbacks_) {
-    MessageLoop::current()->CancelTask(it.second->timeout_id);
-  }
-}
-
-ProxyRequestId ChromeBrowserProxyResolver::GetProxiesForUrl(
-    const string& url, const ProxiesResolvedFn& callback) {
-  int timeout = timeout_;
-  brillo::ErrorPtr error;
-  if (!libcros_proxy_->service_interface_proxy()->ResolveNetworkProxy(
-          url.c_str(),
-          kLibCrosProxyResolveSignalInterface,
-          kLibCrosProxyResolveName,
-          &error)) {
-    LOG(WARNING) << "Can't resolve the proxy. Continuing with no proxy.";
-    timeout = 0;
-  }
-
-  std::unique_ptr<ProxyRequestData> request(new ProxyRequestData());
-  request->callback = callback;
-  ProxyRequestId timeout_id = MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ChromeBrowserProxyResolver::HandleTimeout,
-                 base::Unretained(this),
-                 url,
-                 request.get()),
-      TimeDelta::FromSeconds(timeout));
-  request->timeout_id = timeout_id;
-  callbacks_.emplace(url, std::move(request));
-
-  // We re-use the timeout_id from the MessageLoop as the request id.
-  return timeout_id;
-}
-
-bool ChromeBrowserProxyResolver::CancelProxyRequest(ProxyRequestId request) {
-  // Finding the timeout_id in the callbacks_ structure requires a linear search
-  // but we expect this operation to not be so frequent and to have just a few
-  // proxy requests, so this should be fast enough.
-  for (auto it = callbacks_.begin(); it != callbacks_.end(); ++it) {
-    if (it->second->timeout_id == request) {
-      MessageLoop::current()->CancelTask(request);
-      callbacks_.erase(it);
-      return true;
-    }
-  }
-  return false;
-}
-
-void ChromeBrowserProxyResolver::ProcessUrlResponse(
-    const string& source_url, const deque<string>& proxies) {
-  // Call all the occurrences of the |source_url| and erase them.
-  auto lower_end = callbacks_.lower_bound(source_url);
-  auto upper_end = callbacks_.upper_bound(source_url);
-  for (auto it = lower_end; it != upper_end; ++it) {
-    ProxyRequestData* request = it->second.get();
-    MessageLoop::current()->CancelTask(request->timeout_id);
-    request->callback.Run(proxies);
-  }
-  callbacks_.erase(lower_end, upper_end);
-}
-
-void ChromeBrowserProxyResolver::OnSignalConnected(const string& interface_name,
-                                                   const string& signal_name,
-                                                   bool successful) {
-  if (!successful) {
-    LOG(ERROR) << "Couldn't connect to the signal " << interface_name << "."
-               << signal_name;
-  }
-}
-
-void ChromeBrowserProxyResolver::OnProxyResolvedSignal(
-    const string& source_url,
-    const string& proxy_info,
-    const string& error_message) {
-  if (!error_message.empty()) {
-    LOG(WARNING) << "ProxyResolved error: " << error_message;
-  }
-  ProcessUrlResponse(source_url, ParseProxyString(proxy_info));
-}
-
-void ChromeBrowserProxyResolver::HandleTimeout(string source_url,
-                                               ProxyRequestData* request) {
-  LOG(INFO) << "Timeout handler called. Seems Chrome isn't responding.";
-  // Mark the timer_id that produced this callback as invalid to prevent
-  // canceling the timeout callback that already fired.
-  request->timeout_id = MessageLoop::kTaskIdNull;
-
-  deque<string> proxies = {kNoProxy};
-  ProcessUrlResponse(source_url, proxies);
-}
-
+// static
 deque<string> ChromeBrowserProxyResolver::ParseProxyString(
     const string& input) {
   deque<string> ret;
@@ -193,4 +89,50 @@
   return ret;
 }
 
-}  // namespace chromeos_update_engine
+ProxyRequestId ChromeBrowserProxyResolver::GetProxiesForUrl(
+    const string& url, const ProxiesResolvedFn& callback) {
+  const ProxyRequestId id = next_request_id_++;
+  dbus_proxy_->ResolveProxyAsync(
+      url,
+      base::Bind(&ChromeBrowserProxyResolver::OnResolveProxyResponse,
+                 weak_ptr_factory_.GetWeakPtr(), id),
+      base::Bind(&ChromeBrowserProxyResolver::OnResolveProxyError,
+                 weak_ptr_factory_.GetWeakPtr(), id),
+      kTimeoutMs);
+  pending_callbacks_[id] = callback;
+  return id;
+}
+
+bool ChromeBrowserProxyResolver::CancelProxyRequest(ProxyRequestId request) {
+  return pending_callbacks_.erase(request) != 0;
+}
+
+void ChromeBrowserProxyResolver::OnResolveProxyResponse(
+    ProxyRequestId request_id,
+    const std::string& proxy_info,
+    const std::string& error_message) {
+  if (!error_message.empty())
+    LOG(WARNING) << "Got error resolving proxy: " << error_message;
+  RunCallback(request_id, ParseProxyString(proxy_info));
+}
+
+void ChromeBrowserProxyResolver::OnResolveProxyError(ProxyRequestId request_id,
+                                                     brillo::Error* error) {
+  LOG(WARNING) << "Failed to resolve proxy: "
+               << (error ? error->GetMessage() : "[null]");
+  RunCallback(request_id, deque<string>{kNoProxy});
+}
+
+void ChromeBrowserProxyResolver::RunCallback(
+    ProxyRequestId request_id,
+    const std::deque<std::string>& proxies) {
+  auto it = pending_callbacks_.find(request_id);
+  if (it == pending_callbacks_.end())
+    return;
+
+  ProxiesResolvedFn callback = it->second;
+  pending_callbacks_.erase(it);
+  callback.Run(proxies);
+}
+
+} // namespace chromeos_update_engine
diff --git a/chrome_browser_proxy_resolver.h b/chrome_browser_proxy_resolver.h
index eb92bac..03dbdad 100644
--- a/chrome_browser_proxy_resolver.h
+++ b/chrome_browser_proxy_resolver.h
@@ -18,78 +18,66 @@
 #define UPDATE_ENGINE_CHROME_BROWSER_PROXY_RESOLVER_H_
 
 #include <deque>
+#include <map>
 #include <string>
 
-#include <gtest/gtest_prod.h>  // for FRIEND_TEST
+#include <base/memory/weak_ptr.h>
 
-#include <brillo/message_loops/message_loop.h>
-
-#include "update_engine/libcros_proxy.h"
 #include "update_engine/proxy_resolver.h"
 
+namespace brillo {
+class Error;
+}  // namespace brillo
+
+namespace org {
+namespace chromium {
+class NetworkProxyServiceInterfaceProxyInterface;
+}  // namespace chromium
+}  // namespace org
+
 namespace chromeos_update_engine {
 
-extern const char kLibCrosServiceName[];
-extern const char kLibCrosProxyResolveName[];
-extern const char kLibCrosProxyResolveSignalInterface[];
-
 class ChromeBrowserProxyResolver : public ProxyResolver {
  public:
-  explicit ChromeBrowserProxyResolver(LibCrosProxy* libcros_proxy);
+  explicit ChromeBrowserProxyResolver(
+      org::chromium::NetworkProxyServiceInterfaceProxyInterface* dbus_proxy);
   ~ChromeBrowserProxyResolver() override;
 
-  // Initialize the ProxyResolver using the provided DBus proxies.
-  bool Init();
-
-  ProxyRequestId GetProxiesForUrl(const std::string& url,
-                                  const ProxiesResolvedFn& callback) override;
-  bool CancelProxyRequest(ProxyRequestId request) override;
-
- private:
-  FRIEND_TEST(ChromeBrowserProxyResolverTest, ParseTest);
-  FRIEND_TEST(ChromeBrowserProxyResolverTest, SuccessTest);
-  struct ProxyRequestData {
-    brillo::MessageLoop::TaskId timeout_id;
-    ProxiesResolvedFn callback;
-  };
-  typedef std::multimap<std::string, std::unique_ptr<ProxyRequestData>>
-      CallbacksMap;
-
-  // Called when the signal in UpdateEngineLibcrosProxyResolvedInterface is
-  // connected.
-  void OnSignalConnected(const std::string& interface_name,
-                         const std::string& signal_name,
-                         bool successful);
-
-  // Handle a reply from Chrome:
-  void OnProxyResolvedSignal(const std::string& source_url,
-                             const std::string& proxy_info,
-                             const std::string& error_message);
-
-  // Handle no reply. The |request| pointer points to the ProxyRequestData in
-  // the |callbacks_| map that triggered this timeout.
-  void HandleTimeout(std::string source_url, ProxyRequestData* request);
-
   // Parses a string-encoded list of proxies and returns a deque
   // of individual proxies. The last one will always be kNoProxy.
   static std::deque<std::string> ParseProxyString(const std::string& input);
 
-  // Process a proxy response by calling all the callbacks associated with the
-  // passed |source_url|. All the timeouts associated with these callbacks will
-  // be removed.
-  void ProcessUrlResponse(const std::string& source_url,
-                          const std::deque<std::string>& proxies);
+  // ProxyResolver:
+  ProxyRequestId GetProxiesForUrl(const std::string& url,
+                                  const ProxiesResolvedFn& callback) override;
+  bool CancelProxyRequest(ProxyRequestId request) override;
 
-  // Shutdown the dbus proxy object.
-  void Shutdown();
+private:
+  // Callback for successful D-Bus calls made by GetProxiesForUrl().
+  void OnResolveProxyResponse(ProxyRequestId request_id,
+                              const std::string& proxy_info,
+                              const std::string& error_message);
 
-  // DBus proxies to request a HTTP proxy resolution. The request is done in the
-  // service_interface_proxy() interface and the response is received as a
-  // signal in the ue_proxy_resolved_interface().
-  LibCrosProxy* libcros_proxy_;
+  // Callback for failed D-Bus calls made by GetProxiesForUrl().
+  void OnResolveProxyError(ProxyRequestId request_id, brillo::Error* error);
 
-  int timeout_;
-  CallbacksMap callbacks_;
+  // Finds the callback identified by |request_id| in |pending_callbacks_|,
+  // passes |proxies| to it, and deletes it. Does nothing if the request has
+  // been cancelled.
+  void RunCallback(ProxyRequestId request_id,
+                   const std::deque<std::string>& proxies);
+
+  // D-Bus proxy for resolving network proxies.
+  org::chromium::NetworkProxyServiceInterfaceProxyInterface* dbus_proxy_;
+
+  // Next ID to return from GetProxiesForUrl().
+  ProxyRequestId next_request_id_;
+
+  // Callbacks that were passed to GetProxiesForUrl() but haven't yet been run.
+  std::map<ProxyRequestId, ProxiesResolvedFn> pending_callbacks_;
+
+  base::WeakPtrFactory<ChromeBrowserProxyResolver> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeBrowserProxyResolver);
 };
 
diff --git a/chrome_browser_proxy_resolver_unittest.cc b/chrome_browser_proxy_resolver_unittest.cc
index 24f8a2e..dc71d2b 100644
--- a/chrome_browser_proxy_resolver_unittest.cc
+++ b/chrome_browser_proxy_resolver_unittest.cc
@@ -20,147 +20,68 @@
 #include <string>
 #include <vector>
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include <base/bind.h>
-#include <brillo/make_unique_ptr.h>
-#include <brillo/message_loops/fake_message_loop.h>
+#include <base/macros.h>
+#include <brillo/errors/error.h>
 
-#include "libcros/dbus-proxies.h"
-#include "libcros/dbus-proxy-mocks.h"
+#include "network_proxy/dbus-proxies.h"
+#include "network_proxy/dbus-proxy-mocks.h"
 #include "update_engine/dbus_test_utils.h"
 
-using ::testing::Return;
+using ::testing::DoAll;
+using ::testing::SaveArg;
 using ::testing::StrEq;
 using ::testing::_;
-using brillo::MessageLoop;
-using org::chromium::LibCrosServiceInterfaceProxyMock;
-using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyMock;
+using org::chromium::NetworkProxyServiceInterfaceProxyMock;
 using std::deque;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
-class ChromeBrowserProxyResolverTest : public ::testing::Test {
- protected:
-  ChromeBrowserProxyResolverTest()
-      : service_interface_mock_(new LibCrosServiceInterfaceProxyMock()),
-        ue_proxy_resolved_interface_mock_(
-            new UpdateEngineLibcrosProxyResolvedInterfaceProxyMock()),
-        libcros_proxy_(
-            brillo::make_unique_ptr(service_interface_mock_),
-            brillo::make_unique_ptr(ue_proxy_resolved_interface_mock_)) {}
-
-  void SetUp() override {
-    loop_.SetAsCurrent();
-    // The ProxyResolved signal should be subscribed to.
-    MOCK_SIGNAL_HANDLER_EXPECT_SIGNAL_HANDLER(
-        ue_proxy_resolved_signal_,
-        *ue_proxy_resolved_interface_mock_,
-        ProxyResolved);
-
-    EXPECT_TRUE(resolver_.Init());
-    // Run the loop once to dispatch the successfully registered signal handler.
-    EXPECT_TRUE(loop_.RunOnce(false));
-  }
-
-  void TearDown() override {
-    EXPECT_FALSE(loop_.PendingTasks());
-  }
-
-  // Send the signal to the callback passed during registration of the
-  // ProxyResolved.
-  void SendReplySignal(const string& source_url,
-                       const string& proxy_info,
-                       const string& error_message);
-
-  void RunTest(bool chrome_replies, bool chrome_alive);
-
-  brillo::FakeMessageLoop loop_{nullptr};
-
-  // Local pointers to the mocks. The instances are owned by the
-  // |libcros_proxy_|.
-  LibCrosServiceInterfaceProxyMock* service_interface_mock_;
-  UpdateEngineLibcrosProxyResolvedInterfaceProxyMock*
-      ue_proxy_resolved_interface_mock_;
-
-  // The registered signal handler for the signal
-  // UpdateEngineLibcrosProxyResolvedInterface.ProxyResolved.
-  chromeos_update_engine::dbus_test_utils::MockSignalHandler<
-      void(const string&, const string&, const string&)>
-      ue_proxy_resolved_signal_;
-
-  LibCrosProxy libcros_proxy_;
-  ChromeBrowserProxyResolver resolver_{&libcros_proxy_};
-};
-
-
-void ChromeBrowserProxyResolverTest::SendReplySignal(
-    const string& source_url,
-    const string& proxy_info,
-    const string& error_message) {
-  ASSERT_TRUE(ue_proxy_resolved_signal_.IsHandlerRegistered());
-  ue_proxy_resolved_signal_.signal_callback().Run(
-      source_url, proxy_info, error_message);
-}
-
 namespace {
-void CheckResponseResolved(const deque<string>& proxies) {
-  EXPECT_EQ(2U, proxies.size());
-  EXPECT_EQ("socks5://192.168.52.83:5555", proxies[0]);
-  EXPECT_EQ(kNoProxy, proxies[1]);
-  MessageLoop::current()->BreakLoop();
+
+// Callback for ProxyResolver::GetProxiesForUrl() that copies |src| to |dest|.
+void CopyProxies(deque<string>* dest, const deque<string>& src) {
+  *dest = src;
 }
 
-void CheckResponseNoReply(const deque<string>& proxies) {
-  EXPECT_EQ(1U, proxies.size());
-  EXPECT_EQ(kNoProxy, proxies[0]);
-  MessageLoop::current()->BreakLoop();
-}
 }  // namespace
 
-// chrome_replies should be set to whether or not we fake a reply from
-// chrome. If there's no reply, the resolver should time out.
-// If chrome_alive is false, assume that sending to chrome fails.
-void ChromeBrowserProxyResolverTest::RunTest(bool chrome_replies,
-                                             bool chrome_alive) {
-  char kUrl[] = "http://example.com/blah";
-  char kProxyConfig[] = "SOCKS5 192.168.52.83:5555;DIRECT";
+class ChromeBrowserProxyResolverTest : public ::testing::Test {
+ public:
+  ChromeBrowserProxyResolverTest() = default;
+  ~ChromeBrowserProxyResolverTest() override = default;
 
-  EXPECT_CALL(*service_interface_mock_,
-              ResolveNetworkProxy(StrEq(kUrl),
-                                  StrEq(kLibCrosProxyResolveSignalInterface),
-                                  StrEq(kLibCrosProxyResolveName),
-                                  _,
-                                  _))
-      .WillOnce(Return(chrome_alive));
-
-  ProxiesResolvedFn get_proxies_response = base::Bind(&CheckResponseNoReply);
-  if (chrome_replies) {
-    get_proxies_response = base::Bind(&CheckResponseResolved);
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ChromeBrowserProxyResolverTest::SendReplySignal,
-                   base::Unretained(this),
-                   kUrl,
-                   kProxyConfig,
-                   ""),
-        base::TimeDelta::FromSeconds(1));
+ protected:
+  // Adds a GoogleMock expectation for a call to |dbus_proxy_|'s
+  // ResolveProxyAsync method to resolve |url|.
+  void AddResolveProxyExpectation(const std::string& url) {
+    EXPECT_CALL(dbus_proxy_, ResolveProxyAsync(StrEq(url), _, _, _))
+        .WillOnce(DoAll(SaveArg<1>(&success_callback_),
+                        SaveArg<2>(&error_callback_)));
   }
 
-  EXPECT_NE(kProxyRequestIdNull,
-            resolver_.GetProxiesForUrl(kUrl, get_proxies_response));
-  MessageLoop::current()->Run();
-}
+  NetworkProxyServiceInterfaceProxyMock dbus_proxy_;
+  ChromeBrowserProxyResolver resolver_{&dbus_proxy_};
 
+  // Callbacks that were passed to |dbus_proxy_|'s ResolveProxyAsync method.
+  base::Callback<void(const std::string&, const std::string&)>
+      success_callback_;
+  base::Callback<void(brillo::Error*)> error_callback_;
 
-TEST_F(ChromeBrowserProxyResolverTest, ParseTest) {
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeBrowserProxyResolverTest);
+};
+
+TEST_F(ChromeBrowserProxyResolverTest, Parse) {
   // Test ideas from
   // http://src.chromium.org/svn/trunk/src/net/proxy/proxy_list_unittest.cc
   vector<string> inputs = {
       "PROXY foopy:10",
-      " DIRECT",  // leading space.
+      " DIRECT", // leading space.
       "PROXY foopy1 ; proxy foopy2;\t DIRECT",
       "proxy foopy1 ; SOCKS foopy2",
       "DIRECT ; proxy foopy1 ; DIRECT ; SOCKS5 foopy2;DIRECT ",
@@ -168,7 +89,8 @@
       "PROXY-foopy:10",
       "PROXY",
       "PROXY foopy1 ; JUNK ; JUNK ; SOCKS5 foopy2 ; ;",
-      "HTTP foopy1; SOCKS5 foopy2"};
+      "HTTP foopy1; SOCKS5 foopy2",
+  };
   vector<deque<string>> outputs = {
       {"http://foopy:10", kNoProxy},
       {kNoProxy},
@@ -179,7 +101,8 @@
       {kNoProxy},
       {kNoProxy},
       {"http://foopy1", "socks5://foopy2", kNoProxy},
-      {"socks5://foopy2", kNoProxy}};
+      {"socks5://foopy2", kNoProxy},
+  };
   ASSERT_EQ(inputs.size(), outputs.size());
 
   for (size_t i = 0; i < inputs.size(); i++) {
@@ -195,44 +118,63 @@
   }
 }
 
-TEST_F(ChromeBrowserProxyResolverTest, SuccessTest) {
-  RunTest(true, true);
+TEST_F(ChromeBrowserProxyResolverTest, Success) {
+  const char kUrl[] = "http://example.com/blah";
+  const char kProxyConfig[] = "SOCKS5 192.168.52.83:5555;DIRECT";
+  AddResolveProxyExpectation(kUrl);
+  deque<string> proxies;
+  resolver_.GetProxiesForUrl(kUrl, base::Bind(&CopyProxies, &proxies));
+
+  // Run the D-Bus success callback and verify that the proxies are passed to
+  // the supplied function.
+  ASSERT_FALSE(success_callback_.is_null());
+  success_callback_.Run(kProxyConfig, string());
+  ASSERT_EQ(2u, proxies.size());
+  EXPECT_EQ("socks5://192.168.52.83:5555", proxies[0]);
+  EXPECT_EQ(kNoProxy, proxies[1]);
 }
 
-TEST_F(ChromeBrowserProxyResolverTest, NoReplyTest) {
-  RunTest(false, true);
+TEST_F(ChromeBrowserProxyResolverTest, Failure) {
+  const char kUrl[] = "http://example.com/blah";
+  AddResolveProxyExpectation(kUrl);
+  deque<string> proxies;
+  resolver_.GetProxiesForUrl(kUrl, base::Bind(&CopyProxies, &proxies));
+
+  // Run the D-Bus error callback and verify that the supplied function is
+  // instructed to use a direct connection.
+  ASSERT_FALSE(error_callback_.is_null());
+  brillo::ErrorPtr error = brillo::Error::Create(FROM_HERE, "", "", "");
+  error_callback_.Run(error.get());
+  ASSERT_EQ(1u, proxies.size());
+  EXPECT_EQ(kNoProxy, proxies[0]);
 }
 
-TEST_F(ChromeBrowserProxyResolverTest, NoChromeTest) {
-  RunTest(false, false);
-}
-
-TEST_F(ChromeBrowserProxyResolverTest, CancelCallbackTest) {
+TEST_F(ChromeBrowserProxyResolverTest, CancelCallback) {
+  const char kUrl[] = "http://example.com/blah";
+  AddResolveProxyExpectation(kUrl);
   int called = 0;
   auto callback = base::Bind(
       [](int* called, const deque<string>& proxies) { (*called)++; }, &called);
+  ProxyRequestId request = resolver_.GetProxiesForUrl(kUrl, callback);
 
-  EXPECT_CALL(*service_interface_mock_, ResolveNetworkProxy(_, _, _, _, _))
-      .Times(4)
-      .WillRepeatedly(Return(true));
-
-  EXPECT_NE(kProxyRequestIdNull,
-            resolver_.GetProxiesForUrl("http://urlA", callback));
-  ProxyRequestId req_b = resolver_.GetProxiesForUrl("http://urlB", callback);
-  // Note that we add twice the same url.
-  ProxyRequestId req_c = resolver_.GetProxiesForUrl("http://urlC", callback);
-  EXPECT_NE(kProxyRequestIdNull,
-            resolver_.GetProxiesForUrl("http://urlC", callback));
-
+  // Cancel the request and then run the D-Bus success callback. The original
+  // callback shouldn't be run.
+  EXPECT_TRUE(resolver_.CancelProxyRequest(request));
+  ASSERT_FALSE(success_callback_.is_null());
+  success_callback_.Run("DIRECT", string());
   EXPECT_EQ(0, called);
-  EXPECT_TRUE(resolver_.CancelProxyRequest(req_b));
-  EXPECT_TRUE(resolver_.CancelProxyRequest(req_c));
-  // Canceling the same request twice should fail even if there's another
-  // request for the same URL.
-  EXPECT_FALSE(resolver_.CancelProxyRequest(req_c));
+}
 
-  loop_.Run();
-  EXPECT_EQ(2, called);
+TEST_F(ChromeBrowserProxyResolverTest, CancelCallbackTwice) {
+  const char kUrl[] = "http://example.com/blah";
+  AddResolveProxyExpectation(kUrl);
+  deque<string> proxies;
+  ProxyRequestId request =
+      resolver_.GetProxiesForUrl(kUrl, base::Bind(&CopyProxies, &proxies));
+
+  // Cancel the same request twice. The second call should fail.
+  EXPECT_TRUE(resolver_.CancelProxyRequest(request));
+  EXPECT_FALSE(resolver_.CancelProxyRequest(request));
 }
 
 }  // namespace chromeos_update_engine
diff --git a/common/http_fetcher.cc b/common/http_fetcher.cc
index 4fd1082..73c0d48 100644
--- a/common/http_fetcher.cc
+++ b/common/http_fetcher.cc
@@ -43,7 +43,7 @@
 }
 
 // Proxy methods to set the proxies, then to pop them off.
-bool HttpFetcher::ResolveProxiesForUrl(const string& url,
+void HttpFetcher::ResolveProxiesForUrl(const string& url,
                                        const Closure& callback) {
   CHECK_EQ(static_cast<Closure*>(nullptr), callback_.get());
   callback_.reset(new Closure(callback));
@@ -54,15 +54,10 @@
         FROM_HERE,
         base::Bind(&HttpFetcher::NoProxyResolverCallback,
                    base::Unretained(this)));
-    return true;
+    return;
   }
   proxy_request_ = proxy_resolver_->GetProxiesForUrl(
       url, base::Bind(&HttpFetcher::ProxiesResolved, base::Unretained(this)));
-  if (proxy_request_ == kProxyRequestIdNull) {
-    callback_.reset();
-    return false;
-  }
-  return true;
 }
 
 void HttpFetcher::NoProxyResolverCallback() {
diff --git a/common/http_fetcher.h b/common/http_fetcher.h
index fb15689..3f7b2e8 100644
--- a/common/http_fetcher.h
+++ b/common/http_fetcher.h
@@ -66,8 +66,7 @@
   void SetPostData(const void* data, size_t size);
 
   // Proxy methods to set the proxies, then to pop them off.
-  // Returns true on success.
-  bool ResolveProxiesForUrl(const std::string& url,
+  void ResolveProxiesForUrl(const std::string& url,
                             const base::Closure& callback);
 
   void SetProxies(const std::deque<std::string>& proxies) {
diff --git a/common/subprocess_unittest.cc b/common/subprocess_unittest.cc
index 7dbdf98..cbc9a85 100644
--- a/common/subprocess_unittest.cc
+++ b/common/subprocess_unittest.cc
@@ -236,7 +236,18 @@
       kBinPath "/sh",
       "-c",
       base::StringPrintf(
-          "echo -n  X >\"%s\"; sleep 60; echo -n  Y >\"%s\"; exit 1",
+          // The 'sleep' launched below could be left behind as an orphaned
+          // process when the 'sh' process is terminated by SIGTERM. As a
+          // remedy, trap SIGTERM and kill the 'sleep' process, which requires
+          // launching 'sleep' in background and then waiting for it.
+          "cleanup() { kill \"${sleep_pid}\"; exit 0; }; "
+          "trap cleanup TERM; "
+          "sleep 60 & "
+          "sleep_pid=$!; "
+          "printf X >\"%s\"; "
+          "wait; "
+          "printf Y >\"%s\"; "
+          "exit 1",
           fifo_path.c_str(),
           fifo_path.c_str())};
   uint32_t tag = Subprocess::Get().Exec(cmd, base::Bind(&CallbackBad));
diff --git a/common/test_utils.cc b/common/test_utils.cc
index dfdc6b8..fb22c80 100644
--- a/common/test_utils.cc
+++ b/common/test_utils.cc
@@ -25,6 +25,7 @@
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
+#include <sys/sysmacros.h>
 #include <sys/types.h>
 #include <sys/xattr.h>
 #include <unistd.h>
diff --git a/common_service.cc b/common_service.cc
index c2473b2..1a41b63 100644
--- a/common_service.cc
+++ b/common_service.cc
@@ -173,8 +173,6 @@
     LogAndSetError(error, FROM_HERE, error_message);
     return false;
   }
-  // Update the weave state because updated the target channel.
-  system_state_->update_attempter()->BroadcastChannel();
   return true;
 }
 
diff --git a/daemon.cc b/daemon.cc
index 4155243..f016fec 100644
--- a/daemon.cc
+++ b/daemon.cc
@@ -20,9 +20,9 @@
 
 #include <base/bind.h>
 #include <base/location.h>
-#if USE_WEAVE || USE_BINDER
+#if USE_BINDER
 #include <binderwrapper/binder_wrapper.h>
-#endif  // USE_WEAVE || USE_BINDER
+#endif  // USE_BINDER
 
 #if USE_OMAHA
 #include "update_engine/real_system_state.h"
@@ -41,10 +41,10 @@
   if (exit_code != EX_OK)
     return exit_code;
 
-#if USE_WEAVE || USE_BINDER
+#if USE_BINDER
   android::BinderWrapper::Create();
   binder_watcher_.Init();
-#endif  // USE_WEAVE || USE_BINDER
+#endif  // USE_BINDER
 
 #if USE_OMAHA
   // Initialize update engine global state but continue if something fails.
diff --git a/daemon.h b/daemon.h
index 5910783..c10bb28 100644
--- a/daemon.h
+++ b/daemon.h
@@ -20,9 +20,9 @@
 #include <memory>
 #include <string>
 
-#if USE_WEAVE || USE_BINDER
+#if USE_BINDER
 #include <brillo/binder_watcher.h>
-#endif  // USE_WEAVE || USE_BINDER
+#endif  // USE_BINDER
 #include <brillo/daemons/daemon.h>
 
 #if USE_BINDER
@@ -63,9 +63,9 @@
   // the main() function.
   Subprocess subprocess_;
 
-#if USE_WEAVE || USE_BINDER
+#if USE_BINDER
   brillo::BinderWatcher binder_watcher_;
-#endif  // USE_WEAVE || USE_BINDER
+#endif  // USE_BINDER
 
 #if USE_BINDER
 #if USE_OMAHA
diff --git a/dbus_bindings/org.chromium.LibCrosService.dbus-xml b/dbus_bindings/org.chromium.LibCrosService.dbus-xml
index 2da1929..3111c63 100644
--- a/dbus_bindings/org.chromium.LibCrosService.dbus-xml
+++ b/dbus_bindings/org.chromium.LibCrosService.dbus-xml
@@ -3,21 +3,8 @@
 <node name="/org/chromium/LibCrosService"
       xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
   <interface name="org.chromium.LibCrosServiceInterface">
-    <method name="ResolveNetworkProxy">
-      <arg name="source_url" type="s" direction="in" />
-      <arg name="signal_interface" type="s" direction="in" />
-      <arg name="signal_name" type="s" direction="in" />
-      <annotation name="org.chromium.DBus.Method.Kind" value="simple" />
-    </method>
     <method name="GetKioskAppRequiredPlatformVersion">
       <arg name="required_platform_version" type="s" direction="out" />
     </method>
   </interface>
-  <interface name="org.chromium.UpdateEngineLibcrosProxyResolvedInterface">
-    <signal name="ProxyResolved">
-      <arg name="source_url" type="s" direction="out" />
-      <arg name="proxy_info" type="s" direction="out" />
-      <arg name="error_message" type="s" direction="out" />
-    </signal>
-  </interface>
 </node>
diff --git a/dbus_bindings/org.chromium.NetworkProxyService.dbus-xml b/dbus_bindings/org.chromium.NetworkProxyService.dbus-xml
new file mode 100644
index 0000000..90686ca
--- /dev/null
+++ b/dbus_bindings/org.chromium.NetworkProxyService.dbus-xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<node name="/org/chromium/NetworkProxyService"
+      xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
+  <interface name="org.chromium.NetworkProxyServiceInterface">
+    <method name="ResolveProxy">
+      <arg name="source_url" type="s" direction="in" />
+      <arg name="proxy_info" type="s" direction="out" />
+      <arg name="error_message" type="s" direction="out" />
+      <annotation name="org.chromium.DBus.Method.Kind" value="async" />
+    </method>
+  </interface>
+</node>
diff --git a/dbus_service.h b/dbus_service.h
index 62984f6..2b36ae9 100644
--- a/dbus_service.h
+++ b/dbus_service.h
@@ -175,9 +175,6 @@
 
   void SendPayloadApplicationComplete(ErrorCode error_code) override {}
 
-  // Channel tracking changes are ignored.
-  void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
-
  private:
   scoped_refptr<dbus::Bus> bus_;
   DBusUpdateEngineService dbus_service_;
diff --git a/fake_system_state.h b/fake_system_state.h
index 030cb07..2225933 100644
--- a/fake_system_state.h
+++ b/fake_system_state.h
@@ -84,8 +84,6 @@
     return update_attempter_;
   }
 
-  inline WeaveServiceInterface* weave_service() override { return nullptr; }
-
   inline OmahaRequestParams* request_params() override {
     return request_params_;
   }
diff --git a/image_properties_chromeos.cc b/image_properties_chromeos.cc
index 024eebf..6bab63f 100644
--- a/image_properties_chromeos.cc
+++ b/image_properties_chromeos.cc
@@ -116,7 +116,7 @@
       GetStringWithDefault(lsb_release, kLsbReleaseAutoUpdateServerKey,
                            constants::kOmahaDefaultProductionURL);
   // Build fingerprint not used in Chrome OS.
-  result.buiild_fingerprint = "";
+  result.build_fingerprint = "";
 
   return result;
 }
diff --git a/libcros_proxy.cc b/libcros_proxy.cc
deleted file mode 100644
index 3aa87cb..0000000
--- a/libcros_proxy.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "update_engine/libcros_proxy.h"
-
-#include "update_engine/dbus_connection.h"
-
-using org::chromium::LibCrosServiceInterfaceProxy;
-using org::chromium::LibCrosServiceInterfaceProxyInterface;
-using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxy;
-using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface;
-
-namespace {
-const char kLibCrosServiceName[] = "org.chromium.LibCrosService";
-}  // namespace
-
-namespace chromeos_update_engine {
-
-LibCrosProxy::LibCrosProxy(
-    std::unique_ptr<LibCrosServiceInterfaceProxyInterface>
-        service_interface_proxy,
-    std::unique_ptr<UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface>
-        ue_proxy_resolved_interface)
-    : service_interface_proxy_(std::move(service_interface_proxy)),
-      ue_proxy_resolved_interface_(std::move(ue_proxy_resolved_interface)) {
-}
-
-LibCrosProxy::LibCrosProxy() {
-  const scoped_refptr<dbus::Bus>& bus = DBusConnection::Get()->GetDBus();
-  service_interface_proxy_.reset(
-      new LibCrosServiceInterfaceProxy(bus, kLibCrosServiceName));
-  ue_proxy_resolved_interface_.reset(
-      new UpdateEngineLibcrosProxyResolvedInterfaceProxy(bus,
-                                                         kLibCrosServiceName));
-}
-
-LibCrosServiceInterfaceProxyInterface* LibCrosProxy::service_interface_proxy() {
-  return service_interface_proxy_.get();
-}
-
-UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface*
-LibCrosProxy::ue_proxy_resolved_interface() {
-  return ue_proxy_resolved_interface_.get();
-}
-
-}  // namespace chromeos_update_engine
diff --git a/libcros_proxy.h b/libcros_proxy.h
deleted file mode 100644
index 03bf312..0000000
--- a/libcros_proxy.h
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef UPDATE_ENGINE_LIBCROS_PROXY_H_
-#define UPDATE_ENGINE_LIBCROS_PROXY_H_
-
-#include <memory>
-
-#include <base/macros.h>
-#include <dbus/bus.h>
-
-#include "libcros/dbus-proxies.h"
-
-namespace chromeos_update_engine {
-
-// This class handles the DBus connection with chrome to resolve proxies. This
-// is a thin class to just hold the generated proxies (real or mocked ones).
-class LibCrosProxy final {
- public:
-  LibCrosProxy();
-  LibCrosProxy(
-      std::unique_ptr<org::chromium::LibCrosServiceInterfaceProxyInterface>
-          service_interface_proxy,
-      std::unique_ptr<
-          org::chromium::
-              UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface>
-          ue_proxy_resolved_interface);
-
-  ~LibCrosProxy() = default;
-
-  // Getters for the two proxies.
-  org::chromium::LibCrosServiceInterfaceProxyInterface*
-  service_interface_proxy();
-  org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface*
-  ue_proxy_resolved_interface();
-
- private:
-  std::unique_ptr<org::chromium::LibCrosServiceInterfaceProxyInterface>
-      service_interface_proxy_;
-  std::unique_ptr<
-      org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface>
-      ue_proxy_resolved_interface_;
-
-  DISALLOW_COPY_AND_ASSIGN(LibCrosProxy);
-};
-
-}  // namespace chromeos_update_engine
-
-#endif  // UPDATE_ENGINE_LIBCROS_PROXY_H_
diff --git a/libcurl_http_fetcher.cc b/libcurl_http_fetcher.cc
index f3d6a18..eac6ea0 100644
--- a/libcurl_http_fetcher.cc
+++ b/libcurl_http_fetcher.cc
@@ -52,9 +52,6 @@
 
 const int kNoNetworkRetrySeconds = 10;
 
-// Socket tag used by all network sockets. See qtaguid kernel module for stats.
-const int kUpdateEngineSocketTag = 0x55417243;  // "CrAU" in little-endian.
-
 // libcurl's CURLOPT_SOCKOPTFUNCTION callback function. Called after the socket
 // is created but before it is connected. This callback tags the created socket
 // so the network usage can be tracked in Android.
@@ -62,6 +59,9 @@
                            curl_socket_t curlfd,
                            curlsocktype /* purpose */) {
 #ifdef __ANDROID__
+  // Socket tag used by all network sockets. See qtaguid kernel module for
+  // stats.
+  const int kUpdateEngineSocketTag = 0x55417243;  // "CrAU" in little-endian.
   qtaguid_tagSocket(curlfd, kUpdateEngineSocketTag, AID_OTA_UPDATE);
 #endif  // __ANDROID__
   return CURL_SOCKOPT_OK;
@@ -346,11 +346,7 @@
   url_ = url;
   auto closure = base::Bind(&LibcurlHttpFetcher::ProxiesResolved,
                             base::Unretained(this));
-  if (!ResolveProxiesForUrl(url_, closure)) {
-    LOG(ERROR) << "Couldn't resolve proxies";
-    if (delegate_)
-      delegate_->TransferComplete(this, false);
-  }
+  ResolveProxiesForUrl(url_, closure);
 }
 
 void LibcurlHttpFetcher::ProxiesResolved() {
diff --git a/p2p_manager.cc b/p2p_manager.cc
index 127e5ff..1ee124d 100644
--- a/p2p_manager.cc
+++ b/p2p_manager.cc
@@ -16,6 +16,9 @@
 
 // This provides access to timestamps with nanosecond resolution in
 // struct stat, See NOTES in stat(2) for details.
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
 #ifndef _BSD_SOURCE
 #define _BSD_SOURCE
 #endif
diff --git a/p2p_manager_unittest.cc b/p2p_manager_unittest.cc
index 463c0e2..5ffb358 100644
--- a/p2p_manager_unittest.cc
+++ b/p2p_manager_unittest.cc
@@ -506,7 +506,18 @@
 
   // Emulate p2p-client exceeding its timeout.
   test_conf_->SetP2PClientCommand({
-      "sh", "-c", "echo http://1.2.3.4/; sleep 2"});
+      "sh", "-c",
+      // The 'sleep' launched below could be left behind as an orphaned
+      // process when the 'sh' process is terminated by SIGTERM. As a
+      // remedy, trap SIGTERM and kill the 'sleep' process, which requires
+      // launching 'sleep' in background and then waiting for it.
+      "cleanup() { kill \"${sleep_pid}\"; exit 0; }; "
+      "trap cleanup TERM; "
+      "sleep 5 & "
+      "sleep_pid=$!; "
+      "echo http://1.2.3.4/; "
+      "wait"
+  });
   manager_->LookupUrlForFile("foobar", 42, TimeDelta::FromMilliseconds(500),
                              base::Bind(ExpectUrl, ""));
   loop_.Run();
diff --git a/payload_consumer/delta_performer.cc b/payload_consumer/delta_performer.cc
index 5bd1a19..c406493 100644
--- a/payload_consumer/delta_performer.cc
+++ b/payload_consumer/delta_performer.cc
@@ -26,7 +26,6 @@
 #include <string>
 #include <vector>
 
-#include <applypatch/imgpatch.h>
 #include <base/files/file_util.h>
 #include <base/format_macros.h>
 #include <base/strings/string_number_conversions.h>
@@ -34,7 +33,7 @@
 #include <base/strings/stringprintf.h>
 #include <brillo/data_encoding.h>
 #include <brillo/make_unique_ptr.h>
-#include <bspatch.h>
+#include <bsdiff/bspatch.h>
 #include <google/protobuf/repeated_field.h>
 
 #include "update_engine/common/constants.h"
@@ -733,10 +732,11 @@
         op_result = PerformSourceBsdiffOperation(op, error);
         break;
       case InstallOperation::IMGDIFF:
-        op_result = PerformImgdiffOperation(op, error);
+        // TODO(deymo): Replace with PUFFIN operation.
+        op_result = false;
         break;
       default:
-       op_result = false;
+        op_result = false;
     }
     if (!HandleOpResult(op_result, InstallOperationTypeName(op.type()), error))
       return false;
@@ -1263,57 +1263,6 @@
   return true;
 }
 
-bool DeltaPerformer::PerformImgdiffOperation(const InstallOperation& operation,
-                                             ErrorCode* error) {
-  // Since we delete data off the beginning of the buffer as we use it,
-  // the data we need should be exactly at the beginning of the buffer.
-  TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
-  TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
-
-  uint64_t src_blocks = GetBlockCount(operation.src_extents());
-  brillo::Blob src_data(src_blocks * block_size_);
-
-  ssize_t bytes_read = 0;
-  for (const Extent& extent : operation.src_extents()) {
-    ssize_t bytes_read_this_iteration = 0;
-    ssize_t bytes_to_read = extent.num_blocks() * block_size_;
-    TEST_AND_RETURN_FALSE(utils::PReadAll(source_fd_,
-                                          &src_data[bytes_read],
-                                          bytes_to_read,
-                                          extent.start_block() * block_size_,
-                                          &bytes_read_this_iteration));
-    TEST_AND_RETURN_FALSE(bytes_read_this_iteration == bytes_to_read);
-    bytes_read += bytes_read_this_iteration;
-  }
-
-  if (operation.has_src_sha256_hash()) {
-    brillo::Blob src_hash;
-    TEST_AND_RETURN_FALSE(HashCalculator::RawHashOfData(src_data, &src_hash));
-    TEST_AND_RETURN_FALSE(ValidateSourceHash(src_hash, operation, error));
-  }
-
-  vector<Extent> target_extents(operation.dst_extents().begin(),
-                                operation.dst_extents().end());
-  DirectExtentWriter writer;
-  TEST_AND_RETURN_FALSE(writer.Init(target_fd_, target_extents, block_size_));
-  TEST_AND_RETURN_FALSE(
-      ApplyImagePatch(src_data.data(),
-                      src_data.size(),
-                      buffer_.data(),
-                      operation.data_length(),
-                      [](const unsigned char* data, ssize_t len, void* token) {
-                        return reinterpret_cast<ExtentWriter*>(token)
-                                       ->Write(data, len)
-                                   ? len
-                                   : 0;
-                      },
-                      &writer) == 0);
-  TEST_AND_RETURN_FALSE(writer.End());
-
-  DiscardBuffer(true, buffer_.size());
-  return true;
-}
-
 bool DeltaPerformer::ExtractSignatureMessageFromOperation(
     const InstallOperation& operation) {
   if (operation.type() != InstallOperation::REPLACE ||
diff --git a/payload_consumer/delta_performer.h b/payload_consumer/delta_performer.h
index 74143e0..71d7178 100644
--- a/payload_consumer/delta_performer.h
+++ b/payload_consumer/delta_performer.h
@@ -254,8 +254,6 @@
                                   ErrorCode* error);
   bool PerformSourceBsdiffOperation(const InstallOperation& operation,
                                     ErrorCode* error);
-  bool PerformImgdiffOperation(const InstallOperation& operation,
-                               ErrorCode* error);
 
   // Extracts the payload signature message from the blob on the |operation| if
   // the offset matches the one specified by the manifest. Returns whether the
diff --git a/payload_consumer/delta_performer_unittest.cc b/payload_consumer/delta_performer_unittest.cc
index 47a95ec..ad0c301 100644
--- a/payload_consumer/delta_performer_unittest.cc
+++ b/payload_consumer/delta_performer_unittest.cc
@@ -87,60 +87,6 @@
     0x00, 0x00, 0x59, 0x5a,
 };
 
-// Gzipped 'abc', generated with:
-// echo -n abc | minigzip | hexdump -v -e '"    " 12/1 "0x%02x, " "\n"'
-const uint8_t kSourceGzippedData[] = {
-    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x4b, 0x4c,
-    0x4a, 0x06, 0x00, 0xc2, 0x41, 0x24, 0x35, 0x03, 0x00, 0x00, 0x00,
-};
-
-// Gzipped 'def', generated with:
-// echo -n def | minigzip | hexdump -v -e '"    " 12/1 "0x%02x, " "\n"'
-const uint8_t kTargetGzippedData[] = {
-    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x4b, 0x49,
-    0x4d, 0x03, 0x00, 0x61, 0xe1, 0xc4, 0x0c, 0x03, 0x00, 0x00, 0x00,
-};
-
-// Imgdiff data, generated with:
-// echo -n abc | minigzip > abc && truncate -s 4096 abc
-// echo -n def | minigzip > def && truncate -s 4096 def
-// imgdiff abc def patch && hexdump -v -e '"    " 12/1 "0x%02x, " "\n"' patch
-const uint8_t kImgdiffData[] = {
-    0x49, 0x4d, 0x47, 0x44, 0x49, 0x46, 0x46, 0x32, 0x03, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1f, 0x8b, 0x08, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xf1, 0xff,
-    0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x0f,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x42, 0x53, 0x44, 0x49, 0x46, 0x46, 0x34, 0x30, 0x2a, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x5a,
-    0x68, 0x39, 0x31, 0x41, 0x59, 0x26, 0x53, 0x59, 0xc3, 0xc8, 0xfb, 0x1f,
-    0x00, 0x00, 0x01, 0x40, 0x00, 0x5c, 0x00, 0x20, 0x00, 0x30, 0xcd, 0x34,
-    0x12, 0x34, 0x54, 0x60, 0x5c, 0xce, 0x2e, 0xe4, 0x8a, 0x70, 0xa1, 0x21,
-    0x87, 0x91, 0xf6, 0x3e, 0x42, 0x5a, 0x68, 0x39, 0x17, 0x72, 0x45, 0x38,
-    0x50, 0x90, 0x00, 0x00, 0x00, 0x00, 0x42, 0x5a, 0x68, 0x39, 0x31, 0x41,
-    0x59, 0x26, 0x53, 0x59, 0x42, 0x3c, 0xb0, 0xf9, 0x00, 0x00, 0x00, 0x01,
-    0x00, 0x07, 0x00, 0x20, 0x00, 0x21, 0x98, 0x19, 0x84, 0x61, 0x77, 0x24,
-    0x53, 0x85, 0x09, 0x04, 0x23, 0xcb, 0x0f, 0x90, 0x42, 0x53, 0x44, 0x49,
-    0x46, 0x46, 0x34, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x0f, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x42, 0x5a, 0x68, 0x39, 0x31, 0x41, 0x59, 0x26,
-    0x53, 0x59, 0x6f, 0x02, 0x77, 0xf3, 0x00, 0x00, 0x07, 0x40, 0x41, 0xe0,
-    0x10, 0xc0, 0x00, 0x00, 0x02, 0x20, 0x00, 0x20, 0x00, 0x21, 0x29, 0xa3,
-    0x10, 0x86, 0x03, 0x84, 0x04, 0xae, 0x5f, 0x17, 0x72, 0x45, 0x38, 0x50,
-    0x90, 0x6f, 0x02, 0x77, 0xf3, 0x42, 0x5a, 0x68, 0x39, 0x31, 0x41, 0x59,
-    0x26, 0x53, 0x59, 0x71, 0x62, 0xbd, 0xa7, 0x00, 0x00, 0x20, 0x40, 0x32,
-    0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x80, 0x00, 0x48, 0x20, 0x00,
-    0x30, 0xc0, 0x02, 0xa5, 0x19, 0xa5, 0x92, 0x6f, 0xc2, 0x5d, 0xac, 0x0e,
-    0x17, 0x72, 0x45, 0x38, 0x50, 0x90, 0x71, 0x62, 0xbd, 0xa7, 0x42, 0x5a,
-    0x68, 0x39, 0x17, 0x72, 0x45, 0x38, 0x50, 0x90, 0x00, 0x00, 0x00, 0x00,
-};
-
 }  // namespace
 
 class DeltaPerformerTest : public ::testing::Test {
@@ -534,33 +480,6 @@
   EXPECT_EQ(expected_data, ApplyPayload(payload_data, source_path, true));
 }
 
-TEST_F(DeltaPerformerTest, ImgdiffOperationTest) {
-  brillo::Blob imgdiff_data(std::begin(kImgdiffData), std::end(kImgdiffData));
-
-  AnnotatedOperation aop;
-  *(aop.op.add_src_extents()) = ExtentForRange(0, 1);
-  *(aop.op.add_dst_extents()) = ExtentForRange(0, 1);
-  aop.op.set_data_offset(0);
-  aop.op.set_data_length(imgdiff_data.size());
-  aop.op.set_type(InstallOperation::IMGDIFF);
-
-  brillo::Blob payload_data = GeneratePayload(imgdiff_data, {aop}, false);
-
-  string source_path;
-  EXPECT_TRUE(utils::MakeTempFile("Source-XXXXXX", &source_path, nullptr));
-  ScopedPathUnlinker path_unlinker(source_path);
-  brillo::Blob source_data(std::begin(kSourceGzippedData),
-                           std::end(kSourceGzippedData));
-  source_data.resize(4096);  // block size
-  EXPECT_TRUE(utils::WriteFile(
-      source_path.c_str(), source_data.data(), source_data.size()));
-
-  brillo::Blob target_data(std::begin(kTargetGzippedData),
-                           std::end(kTargetGzippedData));
-  target_data.resize(4096);  // block size
-  EXPECT_EQ(target_data, ApplyPayload(payload_data, source_path, true));
-}
-
 TEST_F(DeltaPerformerTest, SourceHashMismatchTest) {
   brillo::Blob expected_data = {'f', 'o', 'o'};
   brillo::Blob actual_data = {'b', 'a', 'r'};
diff --git a/payload_consumer/postinstall_runner_action.cc b/payload_consumer/postinstall_runner_action.cc
index 11eec34..27a9ed6 100644
--- a/payload_consumer/postinstall_runner_action.cc
+++ b/payload_consumer/postinstall_runner_action.cc
@@ -360,6 +360,8 @@
     return;
   if (kill(current_command_, SIGSTOP) != 0) {
     PLOG(ERROR) << "Couldn't pause child process " << current_command_;
+  } else {
+    is_current_command_suspended_ = true;
   }
 }
 
@@ -368,6 +370,8 @@
     return;
   if (kill(current_command_, SIGCONT) != 0) {
     PLOG(ERROR) << "Couldn't resume child process " << current_command_;
+  } else {
+    is_current_command_suspended_ = false;
   }
 }
 
@@ -377,6 +381,13 @@
   // Calling KillExec() will discard the callback we registered and therefore
   // the unretained reference to this object.
   Subprocess::Get().KillExec(current_command_);
+
+  // If the command has been suspended, resume it after KillExec() so that the
+  // process can process the SIGTERM sent by KillExec().
+  if (is_current_command_suspended_) {
+    ResumeAction();
+  }
+
   current_command_ = 0;
   Cleanup();
 }
diff --git a/payload_consumer/postinstall_runner_action.h b/payload_consumer/postinstall_runner_action.h
index 2bde3ca..2e48e11 100644
--- a/payload_consumer/postinstall_runner_action.h
+++ b/payload_consumer/postinstall_runner_action.h
@@ -134,6 +134,9 @@
   // Postinstall command currently running, or 0 if no program running.
   pid_t current_command_{0};
 
+  // True if |current_command_| has been suspended by SuspendAction().
+  bool is_current_command_suspended_{false};
+
   // The parent progress file descriptor used to watch for progress reports from
   // the postinstall program and the task watching for them.
   int progress_fd_{-1};
diff --git a/payload_generator/ab_generator.cc b/payload_generator/ab_generator.cc
index efb8ccf..3b0d012 100644
--- a/payload_generator/ab_generator.cc
+++ b/payload_generator/ab_generator.cc
@@ -88,14 +88,19 @@
                                      BlobFileWriter* blob_file) {
   vector<AnnotatedOperation> fragmented_aops;
   for (const AnnotatedOperation& aop : *aops) {
-    if (aop.op.type() == InstallOperation::SOURCE_COPY) {
-      TEST_AND_RETURN_FALSE(SplitSourceCopy(aop, &fragmented_aops));
-    } else if (IsAReplaceOperation(aop.op.type())) {
-      TEST_AND_RETURN_FALSE(SplitAReplaceOp(
-          version, aop, target_part_path, &fragmented_aops, blob_file));
-    } else {
-      fragmented_aops.push_back(aop);
+    // Only do split if the operation has more than one dst extents.
+    if (aop.op.dst_extents_size() > 1) {
+      if (aop.op.type() == InstallOperation::SOURCE_COPY) {
+        TEST_AND_RETURN_FALSE(SplitSourceCopy(aop, &fragmented_aops));
+        continue;
+      }
+      if (IsAReplaceOperation(aop.op.type())) {
+        TEST_AND_RETURN_FALSE(SplitAReplaceOp(
+            version, aop, target_part_path, &fragmented_aops, blob_file));
+        continue;
+      }
     }
+    fragmented_aops.push_back(aop);
   }
   *aops = std::move(fragmented_aops);
   return true;
@@ -139,8 +144,6 @@
     // Fix up our new operation and add it to the results.
     new_op.set_type(InstallOperation::SOURCE_COPY);
     *(new_op.add_dst_extents()) = dst_ext;
-    new_op.set_src_length(dst_ext.num_blocks() * kBlockSize);
-    new_op.set_dst_length(dst_ext.num_blocks() * kBlockSize);
 
     AnnotatedOperation new_aop;
     new_aop.op = new_op;
diff --git a/payload_generator/ab_generator_unittest.cc b/payload_generator/ab_generator_unittest.cc
index 3fd2323..ab4b164 100644
--- a/payload_generator/ab_generator_unittest.cc
+++ b/payload_generator/ab_generator_unittest.cc
@@ -354,11 +354,11 @@
   EXPECT_EQ("SplitSourceCopyTestOp:0", result_ops[0].name);
   InstallOperation first_op = result_ops[0].op;
   EXPECT_EQ(InstallOperation::SOURCE_COPY, first_op.type());
-  EXPECT_EQ(kBlockSize * 2, first_op.src_length());
+  EXPECT_FALSE(first_op.has_src_length());
   EXPECT_EQ(1, first_op.src_extents().size());
   EXPECT_EQ(2U, first_op.src_extents(0).start_block());
   EXPECT_EQ(2U, first_op.src_extents(0).num_blocks());
-  EXPECT_EQ(kBlockSize * 2, first_op.dst_length());
+  EXPECT_FALSE(first_op.has_dst_length());
   EXPECT_EQ(1, first_op.dst_extents().size());
   EXPECT_EQ(10U, first_op.dst_extents(0).start_block());
   EXPECT_EQ(2U, first_op.dst_extents(0).num_blocks());
@@ -366,7 +366,7 @@
   EXPECT_EQ("SplitSourceCopyTestOp:1", result_ops[1].name);
   InstallOperation second_op = result_ops[1].op;
   EXPECT_EQ(InstallOperation::SOURCE_COPY, second_op.type());
-  EXPECT_EQ(kBlockSize * 3, second_op.src_length());
+  EXPECT_FALSE(second_op.has_src_length());
   EXPECT_EQ(3, second_op.src_extents().size());
   EXPECT_EQ(4U, second_op.src_extents(0).start_block());
   EXPECT_EQ(1U, second_op.src_extents(0).num_blocks());
@@ -374,7 +374,7 @@
   EXPECT_EQ(1U, second_op.src_extents(1).num_blocks());
   EXPECT_EQ(8U, second_op.src_extents(2).start_block());
   EXPECT_EQ(1U, second_op.src_extents(2).num_blocks());
-  EXPECT_EQ(kBlockSize * 3, second_op.dst_length());
+  EXPECT_FALSE(second_op.has_dst_length());
   EXPECT_EQ(1, second_op.dst_extents().size());
   EXPECT_EQ(14U, second_op.dst_extents(0).start_block());
   EXPECT_EQ(3U, second_op.dst_extents(0).num_blocks());
@@ -382,11 +382,11 @@
   EXPECT_EQ("SplitSourceCopyTestOp:2", result_ops[2].name);
   InstallOperation third_op = result_ops[2].op;
   EXPECT_EQ(InstallOperation::SOURCE_COPY, third_op.type());
-  EXPECT_EQ(kBlockSize * 3, third_op.src_length());
+  EXPECT_FALSE(third_op.has_src_length());
   EXPECT_EQ(1, third_op.src_extents().size());
   EXPECT_EQ(9U, third_op.src_extents(0).start_block());
   EXPECT_EQ(3U, third_op.src_extents(0).num_blocks());
-  EXPECT_EQ(kBlockSize * 3, third_op.dst_length());
+  EXPECT_FALSE(third_op.has_dst_length());
   EXPECT_EQ(1, third_op.dst_extents().size());
   EXPECT_EQ(18U, third_op.dst_extents(0).start_block());
   EXPECT_EQ(3U, third_op.dst_extents(0).num_blocks());
@@ -445,8 +445,6 @@
   vector<AnnotatedOperation> aops;
   InstallOperation first_op;
   first_op.set_type(InstallOperation::SOURCE_COPY);
-  first_op.set_src_length(kBlockSize);
-  first_op.set_dst_length(kBlockSize);
   *(first_op.add_src_extents()) = ExtentForRange(1, 1);
   *(first_op.add_dst_extents()) = ExtentForRange(6, 1);
   AnnotatedOperation first_aop;
@@ -456,8 +454,6 @@
 
   InstallOperation second_op;
   second_op.set_type(InstallOperation::SOURCE_COPY);
-  second_op.set_src_length(3 * kBlockSize);
-  second_op.set_dst_length(3 * kBlockSize);
   *(second_op.add_src_extents()) = ExtentForRange(2, 2);
   *(second_op.add_src_extents()) = ExtentForRange(8, 2);
   *(second_op.add_dst_extents()) = ExtentForRange(7, 3);
@@ -469,8 +465,6 @@
 
   InstallOperation third_op;
   third_op.set_type(InstallOperation::SOURCE_COPY);
-  third_op.set_src_length(kBlockSize);
-  third_op.set_dst_length(kBlockSize);
   *(third_op.add_src_extents()) = ExtentForRange(11, 1);
   *(third_op.add_dst_extents()) = ExtentForRange(12, 1);
   AnnotatedOperation third_aop;
@@ -486,12 +480,12 @@
   EXPECT_EQ(1U, aops.size());
   InstallOperation first_result_op = aops[0].op;
   EXPECT_EQ(InstallOperation::SOURCE_COPY, first_result_op.type());
-  EXPECT_EQ(kBlockSize * 5, first_result_op.src_length());
+  EXPECT_FALSE(first_result_op.has_src_length());
   EXPECT_EQ(3, first_result_op.src_extents().size());
   EXPECT_TRUE(ExtentEquals(first_result_op.src_extents(0), 1, 3));
   EXPECT_TRUE(ExtentEquals(first_result_op.src_extents(1), 8, 2));
   EXPECT_TRUE(ExtentEquals(first_result_op.src_extents(2), 11, 1));
-  EXPECT_EQ(kBlockSize * 5, first_result_op.dst_length());
+  EXPECT_FALSE(first_result_op.has_dst_length());
   EXPECT_EQ(2, first_result_op.dst_extents().size());
   EXPECT_TRUE(ExtentEquals(first_result_op.dst_extents(0), 6, 4));
   EXPECT_TRUE(ExtentEquals(first_result_op.dst_extents(1), 11, 2));
diff --git a/payload_generator/delta_diff_utils.cc b/payload_generator/delta_diff_utils.cc
index 44aff7a..045d52f 100644
--- a/payload_generator/delta_diff_utils.cc
+++ b/payload_generator/delta_diff_utils.cc
@@ -22,7 +22,7 @@
 #pragma clang diagnostic ignored "-Wmacro-redefined"
 #include <ext2fs/ext2fs.h>
 #pragma clang diagnostic pop
-
+#include <unistd.h>
 
 #include <algorithm>
 #include <map>
@@ -30,6 +30,7 @@
 #include <base/files/file_util.h>
 #include <base/format_macros.h>
 #include <base/strings/stringprintf.h>
+#include <base/threading/simple_thread.h>
 
 #include "update_engine/common/hash_calculator.h"
 #include "update_engine/common/subprocess.h"
@@ -171,6 +172,81 @@
 
 namespace diff_utils {
 
+// This class encapsulates a file delta processing thread work. The
+// processor computes the delta between the source and target files;
+// and write the compressed delta to the blob.
+class FileDeltaProcessor : public base::DelegateSimpleThread::Delegate {
+ public:
+  FileDeltaProcessor(const string& old_part,
+                     const string& new_part,
+                     const PayloadVersion& version,
+                     const vector<Extent>& old_extents,
+                     const vector<Extent>& new_extents,
+                     const string& name,
+                     ssize_t chunk_blocks,
+                     BlobFileWriter* blob_file)
+      : old_part_(old_part),
+        new_part_(new_part),
+        version_(version),
+        old_extents_(old_extents),
+        new_extents_(new_extents),
+        name_(name),
+        chunk_blocks_(chunk_blocks),
+        blob_file_(blob_file) {}
+
+  FileDeltaProcessor(FileDeltaProcessor&& processor) = default;
+
+  ~FileDeltaProcessor() override = default;
+
+  // Overrides DelegateSimpleThread::Delegate.
+  // Calculate the list of operations and write their corresponding deltas to
+  // the blob_file.
+  void Run() override;
+
+  // Merge each file processor's ops list to aops.
+  void MergeOperation(vector<AnnotatedOperation>* aops);
+
+ private:
+  const string& old_part_;
+  const string& new_part_;
+  const PayloadVersion& version_;
+
+  // The block ranges of the old/new file within the src/tgt image
+  const vector<Extent> old_extents_;
+  const vector<Extent> new_extents_;
+  const string name_;
+  // Block limit of one aop.
+  ssize_t chunk_blocks_;
+  BlobFileWriter* blob_file_;
+
+  // The list of ops to reach the new file from the old file.
+  vector<AnnotatedOperation> file_aops_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileDeltaProcessor);
+};
+
+void FileDeltaProcessor::Run() {
+  TEST_AND_RETURN(blob_file_ != nullptr);
+
+  if (!DeltaReadFile(&file_aops_,
+                     old_part_,
+                     new_part_,
+                     old_extents_,
+                     new_extents_,
+                     name_,
+                     chunk_blocks_,
+                     version_,
+                     blob_file_)) {
+    LOG(ERROR) << "Failed to generate delta for " << name_ << " ("
+               << BlocksInExtents(new_extents_) << " blocks)";
+  }
+}
+
+void FileDeltaProcessor::MergeOperation(vector<AnnotatedOperation>* aops) {
+  aops->reserve(aops->size() + file_aops_.size());
+  std::move(file_aops_.begin(), file_aops_.end(), std::back_inserter(*aops));
+}
+
 bool DeltaReadPartition(vector<AnnotatedOperation>* aops,
                         const PartitionConfig& old_part,
                         const PartitionConfig& new_part,
@@ -205,6 +281,8 @@
   vector<FilesystemInterface::File> new_files;
   new_part.fs_interface->GetFiles(&new_files);
 
+  vector<FileDeltaProcessor> file_delta_processors;
+
   // The processing is very straightforward here, we generate operations for
   // every file (and pseudo-file such as the metadata) in the new filesystem
   // based on the file with the same name in the old filesystem, if any.
@@ -239,16 +317,29 @@
         old_files_map[new_file.name], old_visited_blocks);
     old_visited_blocks.AddExtents(old_file_extents);
 
-    TEST_AND_RETURN_FALSE(DeltaReadFile(aops,
-                                        old_part.path,
-                                        new_part.path,
-                                        old_file_extents,
-                                        new_file_extents,
-                                        new_file.name,  // operation name
-                                        hard_chunk_blocks,
-                                        version,
-                                        blob_file));
+    file_delta_processors.emplace_back(old_part.path,
+                                       new_part.path,
+                                       version,
+                                       std::move(old_file_extents),
+                                       std::move(new_file_extents),
+                                       new_file.name,  // operation name
+                                       hard_chunk_blocks,
+                                       blob_file);
   }
+
+  size_t max_threads = GetMaxThreads();
+  base::DelegateSimpleThreadPool thread_pool("incremental-update-generator",
+                                             max_threads);
+  thread_pool.Start();
+  for (auto& processor : file_delta_processors) {
+    thread_pool.AddWork(&processor);
+  }
+  thread_pool.JoinAll();
+
+  for (auto& processor : file_delta_processors) {
+    processor.MergeOperation(aops);
+  }
+
   // Process all the blocks not included in any file. We provided all the unused
   // blocks in the old partition as available data.
   vector<Extent> new_unvisited = {
@@ -807,6 +898,11 @@
   return true;
 }
 
+// Return the number of CPUs on the machine, and 4 threads in minimum.
+size_t GetMaxThreads() {
+  return std::max(sysconf(_SC_NPROCESSORS_ONLN), 4L);
+}
+
 }  // namespace diff_utils
 
 }  // namespace chromeos_update_engine
diff --git a/payload_generator/delta_diff_utils.h b/payload_generator/delta_diff_utils.h
index 7254bca..c9fef17 100644
--- a/payload_generator/delta_diff_utils.h
+++ b/payload_generator/delta_diff_utils.h
@@ -143,6 +143,9 @@
 // false.
 bool IsExtFilesystem(const std::string& device);
 
+// Returns the max number of threads to process the files(chunks) in parallel.
+size_t GetMaxThreads();
+
 }  // namespace diff_utils
 
 }  // namespace chromeos_update_engine
diff --git a/payload_generator/full_update_generator.cc b/payload_generator/full_update_generator.cc
index 8fdb6ec..482a789 100644
--- a/payload_generator/full_update_generator.cc
+++ b/payload_generator/full_update_generator.cc
@@ -139,7 +139,7 @@
   TEST_AND_RETURN_FALSE(full_chunk_size % config.block_size == 0);
 
   size_t chunk_blocks = full_chunk_size / config.block_size;
-  size_t max_threads = std::max(sysconf(_SC_NPROCESSORS_ONLN), 4L);
+  size_t max_threads = diff_utils::GetMaxThreads();
   LOG(INFO) << "Compressing partition " << new_part.name
             << " from " << new_part.path << " splitting in chunks of "
             << chunk_blocks << " blocks (" << config.block_size
diff --git a/real_system_state.cc b/real_system_state.cc
index 5fc0b71..5cbf723 100644
--- a/real_system_state.cc
+++ b/real_system_state.cc
@@ -24,14 +24,19 @@
 #include <base/time/time.h>
 #include <brillo/make_unique_ptr.h>
 #include <brillo/message_loops/message_loop.h>
+#if USE_LIBCROS
+#include <chromeos/dbus/service_constants.h>
+#endif  // USE_LIBCROS
 
 #include "update_engine/common/boot_control.h"
 #include "update_engine/common/boot_control_stub.h"
 #include "update_engine/common/constants.h"
 #include "update_engine/common/hardware.h"
 #include "update_engine/common/utils.h"
+#if USE_DBUS
+#include "update_engine/dbus_connection.h"
+#endif  // USE_DBUS
 #include "update_engine/update_manager/state_factory.h"
-#include "update_engine/weave_service_factory.h"
 
 using brillo::MessageLoop;
 
@@ -60,6 +65,15 @@
     return false;
   }
 
+#if USE_LIBCROS
+  libcros_proxy_.reset(new org::chromium::LibCrosServiceInterfaceProxy(
+      DBusConnection::Get()->GetDBus(), chromeos::kLibCrosServiceName));
+  network_proxy_service_proxy_.reset(
+      new org::chromium::NetworkProxyServiceInterfaceProxy(
+          DBusConnection::Get()->GetDBus(),
+          chromeos::kNetworkProxyServiceName));
+#endif  // USE_LIBCROS
+
   LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode.";
   LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build.";
 
@@ -130,20 +144,22 @@
   certificate_checker_->Init();
 
 #if USE_LIBCROS
-  LibCrosProxy* libcros_proxy = &libcros_proxy_;
+  org::chromium::NetworkProxyServiceInterfaceProxyInterface* net_proxy =
+      network_proxy_service_proxy_.get();
+  org::chromium::LibCrosServiceInterfaceProxyInterface* libcros_proxy =
+      libcros_proxy_.get();
 #else
-  LibCrosProxy* libcros_proxy = nullptr;
+  org::chromium::NetworkProxyServiceInterfaceProxyInterface* net_proxy =
+      nullptr;
+  org::chromium::LibCrosServiceInterfaceProxyInterface* libcros_proxy =
+      nullptr;
 #endif  // USE_LIBCROS
 
   // Initialize the UpdateAttempter before the UpdateManager.
-  update_attempter_.reset(
-      new UpdateAttempter(this, certificate_checker_.get(), libcros_proxy));
+  update_attempter_.reset(new UpdateAttempter(this, certificate_checker_.get(),
+                                              net_proxy));
   update_attempter_->Init();
 
-  weave_service_ = ConstructWeaveService(update_attempter_.get());
-  if (weave_service_)
-    update_attempter_->AddObserver(weave_service_.get());
-
   // Initialize the Update Manager using the default state factory.
   chromeos_update_manager::State* um_state =
       chromeos_update_manager::DefaultStateFactory(
diff --git a/real_system_state.h b/real_system_state.h
index 0964f10..64964cd 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -25,6 +25,11 @@
 #include <metrics/metrics_library.h>
 #include <policy/device_policy.h>
 
+#if USE_LIBCROS
+#include <libcros/dbus-proxies.h>
+#include <network_proxy/dbus-proxies.h>
+#endif  // USE_LIBCROS
+
 #include "update_engine/certificate_checker.h"
 #include "update_engine/common/boot_control_interface.h"
 #include "update_engine/common/clock.h"
@@ -37,7 +42,6 @@
 #include "update_engine/power_manager_interface.h"
 #include "update_engine/update_attempter.h"
 #include "update_engine/update_manager/update_manager.h"
-#include "update_engine/weave_service_interface.h"
 
 namespace chromeos_update_engine {
 
@@ -106,10 +110,6 @@
     return update_attempter_.get();
   }
 
-  inline WeaveServiceInterface* weave_service() override {
-    return weave_service_.get();
-  }
-
   inline OmahaRequestParams* request_params() override {
     return &request_params_;
   }
@@ -128,8 +128,10 @@
 
  private:
 #if USE_LIBCROS
-  // LibCros proxy using the DBus connection.
-  LibCrosProxy libcros_proxy_;
+  // Real DBus proxies using the DBus connection.
+  std::unique_ptr<org::chromium::LibCrosServiceInterfaceProxy> libcros_proxy_;
+  std::unique_ptr<org::chromium::NetworkProxyServiceInterfaceProxy>
+      network_proxy_service_proxy_;
 #endif  // USE_LIBCROS
 
   // Interface for the power manager.
@@ -176,8 +178,6 @@
 
   std::unique_ptr<P2PManager> p2p_manager_;
 
-  std::unique_ptr<WeaveServiceInterface> weave_service_;
-
   std::unique_ptr<chromeos_update_manager::UpdateManager> update_manager_;
 
   policy::PolicyProvider policy_provider_;
diff --git a/scripts/brillo_update_payload b/scripts/brillo_update_payload
index f7bb799..375c0df 100755
--- a/scripts/brillo_update_payload
+++ b/scripts/brillo_update_payload
@@ -463,6 +463,11 @@
       if [[ "${partitions_array}" == "SRC_PARTITIONS" ]]; then
         echo "Rounding DOWN partition ${part}.img to a multiple of 4 KiB."
         : $(( filesize = filesize & -4096 ))
+        if [[ ${filesize} == 0 ]]; then
+          echo "Source partition ${part}.img is empty after rounding down," \
+            "skipping."
+          continue
+        fi
       else
         echo "Rounding UP partition ${part}.img to a multiple of 4 KiB."
         : $(( filesize = (filesize + 4095) & -4096 ))
diff --git a/service_observer_interface.h b/service_observer_interface.h
index 75a739f..893df04 100644
--- a/service_observer_interface.h
+++ b/service_observer_interface.h
@@ -40,9 +40,6 @@
   // Called whenever an update attempt is completed.
   virtual void SendPayloadApplicationComplete(ErrorCode error_code) = 0;
 
-  // Called whenever the channel we are tracking changes.
-  virtual void SendChannelChangeUpdate(const std::string& tracking_channel) = 0;
-
  protected:
   ServiceObserverInterface() = default;
 };
diff --git a/sideload_main.cc b/sideload_main.cc
index d02af0e..574d062 100644
--- a/sideload_main.cc
+++ b/sideload_main.cc
@@ -112,8 +112,6 @@
     brillo::MessageLoop::current()->BreakLoop();
   }
 
-  void SendChannelChangeUpdate(const string& tracking_channel) override {}
-
   // Getters.
   UpdateStatus status() { return status_; }
   ErrorCode error_code() { return error_code_; }
diff --git a/system_state.h b/system_state.h
index 4d040ec..d538427 100644
--- a/system_state.h
+++ b/system_state.h
@@ -46,7 +46,6 @@
 class PowerManagerInterface;
 class PrefsInterface;
 class UpdateAttempter;
-class WeaveServiceInterface;
 
 // An interface to global system context, including platform resources,
 // the current state of the system, high-level objects whose lifetime is same
@@ -94,9 +93,6 @@
   // Returns a pointer to the update attempter object.
   virtual UpdateAttempter* update_attempter() = 0;
 
-  // Returns a pointer to the WeaveServiceInterface class or nullptr if none.
-  virtual WeaveServiceInterface* weave_service() = 0;
-
   // Returns a pointer to the object that stores the parameters that are
   // common to all Omaha requests.
   virtual OmahaRequestParams* request_params() = 0;
diff --git a/update_attempter.cc b/update_attempter.cc
index d36f7fd..8e25819 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -119,14 +119,16 @@
   return code;
 }
 
-UpdateAttempter::UpdateAttempter(SystemState* system_state,
-                                 CertificateChecker* cert_checker,
-                                 LibCrosProxy* libcros_proxy)
+UpdateAttempter::UpdateAttempter(
+    SystemState* system_state,
+    CertificateChecker* cert_checker,
+    org::chromium::NetworkProxyServiceInterfaceProxyInterface*
+        network_proxy_service_proxy)
     : processor_(new ActionProcessor()),
       system_state_(system_state),
 #if USE_LIBCROS
       cert_checker_(cert_checker),
-      chrome_proxy_resolver_(libcros_proxy) {
+      chrome_proxy_resolver_(network_proxy_service_proxy) {
 #else
       cert_checker_(cert_checker) {
 #endif  // USE_LIBCROS
@@ -157,10 +159,6 @@
     status_ = UpdateStatus::UPDATED_NEED_REBOOT;
   else
     status_ = UpdateStatus::IDLE;
-
-#if USE_LIBCROS
-  chrome_proxy_resolver_.Init();
-#endif  // USE_LIBCROS
 }
 
 void UpdateAttempter::ScheduleUpdates() {
@@ -371,9 +369,8 @@
   // Refresh the policy before computing all the update parameters.
   RefreshDevicePolicy();
 
-  // Set the target version prefix, if provided.
-  if (!target_version_prefix.empty())
-    omaha_request_params_->set_target_version_prefix(target_version_prefix);
+  // Update the target version prefix.
+  omaha_request_params_->set_target_version_prefix(target_version_prefix);
 
   CalculateScatteringParams(interactive);
 
@@ -409,8 +406,6 @@
                                                  &error_message)) {
       LOG(ERROR) << "Setting the channel failed: " << error_message;
     }
-    // Notify observers the target channel change.
-    BroadcastChannel();
 
     // Since this is the beginning of a new attempt, update the download
     // channel. The download channel won't be updated until the next attempt,
@@ -1066,44 +1061,6 @@
   system_state_->payload_state()->DownloadComplete();
 }
 
-bool UpdateAttempter::OnCheckForUpdates(brillo::ErrorPtr* error) {
-  CheckForUpdate(
-      "" /* app_version */, "" /* omaha_url */, true /* interactive */);
-  return true;
-}
-
-bool UpdateAttempter::OnTrackChannel(const string& channel,
-                                     brillo::ErrorPtr* error) {
-  LOG(INFO) << "Setting destination channel to: " << channel;
-  string error_message;
-  if (!system_state_->request_params()->SetTargetChannel(
-          channel, false /* powerwash_allowed */, &error_message)) {
-    brillo::Error::AddTo(error,
-                         FROM_HERE,
-                         brillo::errors::dbus::kDomain,
-                         "set_target_error",
-                         error_message);
-    return false;
-  }
-  // Notify observers the target channel change.
-  BroadcastChannel();
-  return true;
-}
-
-bool UpdateAttempter::GetWeaveState(int64_t* last_checked_time,
-                                    double* progress,
-                                    UpdateStatus* update_status,
-                                    string* current_channel,
-                                    string* tracking_channel) {
-  *last_checked_time = last_checked_time_;
-  *progress = download_progress_;
-  *update_status = status_;
-  OmahaRequestParams* rp = system_state_->request_params();
-  *current_channel = rp->current_channel();
-  *tracking_channel = rp->target_channel();
-  return true;
-}
-
 void UpdateAttempter::ProgressUpdate(double progress) {
   // Self throttle based on progress. Also send notifications if progress is
   // too slow.
@@ -1221,13 +1178,6 @@
   last_notify_time_ = TimeTicks::Now();
 }
 
-void UpdateAttempter::BroadcastChannel() {
-  for (const auto& observer : service_observers_) {
-    observer->SendChannelChangeUpdate(
-        system_state_->request_params()->target_channel());
-  }
-}
-
 uint32_t UpdateAttempter::GetErrorCodeFlags()  {
   uint32_t flags = 0;
 
diff --git a/update_attempter.h b/update_attempter.h
index 104975c..193e172 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -45,23 +45,26 @@
 #include "update_engine/system_state.h"
 #include "update_engine/update_manager/policy.h"
 #include "update_engine/update_manager/update_manager.h"
-#include "update_engine/weave_service_interface.h"
 
 class MetricsLibraryInterface;
 
+namespace org {
+namespace chromium {
+class NetworkProxyServiceInterfaceProxyInterface;
+}  // namespace chromium
+}  // namespace org
+
 namespace policy {
 class PolicyProvider;
 }
 
 namespace chromeos_update_engine {
 
-class LibCrosProxy;
 class UpdateEngineAdaptor;
 
 class UpdateAttempter : public ActionProcessorDelegate,
                         public DownloadActionDelegate,
                         public CertificateChecker::Observer,
-                        public WeaveServiceInterface::DelegateInterface,
                         public PostinstallRunnerAction::DelegateInterface {
  public:
   using UpdateStatus = update_engine::UpdateStatus;
@@ -69,7 +72,8 @@
 
   UpdateAttempter(SystemState* system_state,
                   CertificateChecker* cert_checker,
-                  LibCrosProxy* libcros_proxy);
+                  org::chromium::NetworkProxyServiceInterfaceProxyInterface*
+                      network_proxy_service_proxy);
   ~UpdateAttempter() override;
 
   // Further initialization to be done post construction.
@@ -100,16 +104,6 @@
                        AbstractAction* action,
                        ErrorCode code) override;
 
-  // WeaveServiceInterface::DelegateInterface overrides.
-  bool OnCheckForUpdates(brillo::ErrorPtr* error) override;
-  bool OnTrackChannel(const std::string& channel,
-                      brillo::ErrorPtr* error) override;
-  bool GetWeaveState(int64_t* last_checked_time,
-                     double* progress,
-                     UpdateStatus* update_status,
-                     std::string* current_channel,
-                     std::string* tracking_channel) override;
-
   // PostinstallRunnerAction::DelegateInterface
   void ProgressUpdate(double progress) override;
 
@@ -181,9 +175,6 @@
   // Broadcasts the current status to all observers.
   void BroadcastStatus();
 
-  // Broadcasts the current tracking channel to all observers.
-  void BroadcastChannel();
-
   // Returns the special flags to be added to ErrorCode values based on the
   // parameters used in the current update attempt.
   uint32_t GetErrorCodeFlags();
@@ -271,6 +262,7 @@
   FRIEND_TEST(UpdateAttempterTest, UpdateTest);
   FRIEND_TEST(UpdateAttempterTest, ReportDailyMetrics);
   FRIEND_TEST(UpdateAttempterTest, BootTimeInUpdateMarkerFile);
+  FRIEND_TEST(UpdateAttempterTest, TargetVersionPrefixSetAndReset);
 
   // CertificateChecker::Observer method.
   // Report metrics about the certificate being checked.
diff --git a/update_attempter_android.cc b/update_attempter_android.cc
index b80ee6e..da43b6a 100644
--- a/update_attempter_android.cc
+++ b/update_attempter_android.cc
@@ -209,7 +209,6 @@
   if (!headers[kPayloadPropertyUserAgent].empty())
     fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);
 
-  cpu_limiter_.StartLimiter();
   SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
   ongoing_update_ = true;
 
@@ -416,8 +415,6 @@
     return;
   }
 
-  // Reset cpu shares back to normal.
-  cpu_limiter_.StopLimiter();
   download_progress_ = 0;
   actions_.clear();
   UpdateStatus new_status =
diff --git a/update_attempter_android.h b/update_attempter_android.h
index 2617318..6a5c227 100644
--- a/update_attempter_android.h
+++ b/update_attempter_android.h
@@ -28,7 +28,6 @@
 #include "update_engine/client_library/include/update_engine/update_status.h"
 #include "update_engine/common/action_processor.h"
 #include "update_engine/common/boot_control_interface.h"
-#include "update_engine/common/cpu_limiter.h"
 #include "update_engine/common/hardware_interface.h"
 #include "update_engine/common/prefs_interface.h"
 #include "update_engine/daemon_state_interface.h"
@@ -160,9 +159,6 @@
   // Only direct proxy supported.
   DirectProxyResolver proxy_resolver_;
 
-  // CPU limiter during the update.
-  CPULimiter cpu_limiter_;
-
   // Helper class to select the network to use during the update.
   std::unique_ptr<NetworkSelectorInterface> network_selector_;
 
diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc
index 94a1b3c..93bcc5c 100644
--- a/update_attempter_unittest.cc
+++ b/update_attempter_unittest.cc
@@ -32,9 +32,8 @@
 #include <policy/mock_device_policy.h>
 
 #if USE_LIBCROS
-#include "libcros/dbus-proxies.h"
-#include "libcros/dbus-proxy-mocks.h"
-#include "update_engine/libcros_proxy.h"
+#include "network_proxy/dbus-proxies.h"
+#include "network_proxy/dbus-proxy-mocks.h"
 #endif // USE_LIBCROS
 #include "update_engine/common/fake_clock.h"
 #include "update_engine/common/fake_prefs.h"
@@ -54,12 +53,16 @@
 #include "update_engine/payload_consumer/payload_constants.h"
 #include "update_engine/payload_consumer/postinstall_runner_action.h"
 
+namespace org {
+namespace chromium {
+class NetworkProxyServiceInterfaceProxyMock;
+}  // namespace chromium
+}  // namespace org
+
 using base::Time;
 using base::TimeDelta;
-#if USE_LIBCROS
-using org::chromium::LibCrosServiceInterfaceProxyMock;
-using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyMock;
-#endif // USE_LIBCROS
+using org::chromium::NetworkProxyServiceInterfaceProxyInterface;
+using org::chromium::NetworkProxyServiceInterfaceProxyMock;
 using std::string;
 using std::unique_ptr;
 using testing::DoAll;
@@ -81,9 +84,10 @@
 // methods.
 class UpdateAttempterUnderTest : public UpdateAttempter {
  public:
-  UpdateAttempterUnderTest(SystemState* system_state,
-                           LibCrosProxy* libcros_proxy)
-      : UpdateAttempter(system_state, nullptr, libcros_proxy) {}
+  UpdateAttempterUnderTest(
+      SystemState* system_state,
+      NetworkProxyServiceInterfaceProxyInterface* network_proxy_service_proxy)
+      : UpdateAttempter(system_state, nullptr, network_proxy_service_proxy) {}
 
   // Wrap the update scheduling method, allowing us to opt out of scheduled
   // updates for testing purposes.
@@ -112,16 +116,7 @@
 class UpdateAttempterTest : public ::testing::Test {
  protected:
   UpdateAttempterTest()
-      :
-#if USE_LIBCROS
-        service_interface_mock_(new LibCrosServiceInterfaceProxyMock()),
-        ue_proxy_resolved_interface_mock_(
-            new NiceMock<UpdateEngineLibcrosProxyResolvedInterfaceProxyMock>()),
-        libcros_proxy_(
-            brillo::make_unique_ptr(service_interface_mock_),
-            brillo::make_unique_ptr(ue_proxy_resolved_interface_mock_)),
-#endif  // USE_LIBCROS
-        certificate_checker_(fake_system_state_.mock_prefs(),
+      : certificate_checker_(fake_system_state_.mock_prefs(),
                              &openssl_wrapper_) {
     // Override system state members.
     fake_system_state_.set_connection_manager(&mock_connection_manager);
@@ -193,11 +188,9 @@
 
   FakeSystemState fake_system_state_;
 #if USE_LIBCROS
-  LibCrosServiceInterfaceProxyMock* service_interface_mock_;
-  UpdateEngineLibcrosProxyResolvedInterfaceProxyMock*
-      ue_proxy_resolved_interface_mock_;
-  LibCrosProxy libcros_proxy_;
-  UpdateAttempterUnderTest attempter_{&fake_system_state_, &libcros_proxy_};
+  NetworkProxyServiceInterfaceProxyMock network_proxy_service_proxy_mock_;
+  UpdateAttempterUnderTest attempter_{&fake_system_state_,
+                                      &network_proxy_service_proxy_mock_};
 #else
   UpdateAttempterUnderTest attempter_{&fake_system_state_, nullptr};
 #endif  // USE_LIBCROS
@@ -978,4 +971,14 @@
   EXPECT_EQ(constants::kOmahaDefaultAUTestURL, attempter_.forced_omaha_url());
 }
 
+TEST_F(UpdateAttempterTest, TargetVersionPrefixSetAndReset) {
+  attempter_.CalculateUpdateParams("", "", "", "1234", false, false);
+  EXPECT_EQ("1234",
+            fake_system_state_.request_params()->target_version_prefix());
+
+  attempter_.CalculateUpdateParams("", "", "", "", false, false);
+  EXPECT_TRUE(
+      fake_system_state_.request_params()->target_version_prefix().empty());
+}
+
 }  // namespace chromeos_update_engine
diff --git a/update_engine.gyp b/update_engine.gyp
index 31296a5..6b7e5f4 100644
--- a/update_engine.gyp
+++ b/update_engine.gyp
@@ -23,13 +23,7 @@
       # The -DUSE_* flags are passed from platform2.py. We use sane defaults
       # here when these USE flags are not defined. You can set the default value
       # for the USE flag in the ebuild.
-      'USE_binder%': '0',
-      'USE_dbus%': '1',
       'USE_hwid_override%': '0',
-      'USE_libcros%': '1',
-      'USE_mtd%': '0',
-      'USE_power_management%': '0',
-      'USE_buffet%': '0',
     },
     'cflags': [
       '-g',
@@ -57,7 +51,6 @@
       'USE_MTD=<(USE_mtd)',
       'USE_OMAHA=1',
       'USE_SHILL=1',
-      'USE_WEAVE=<(USE_buffet)',
     ],
     'include_dirs': [
       # We need this include dir because we include all the local code as
@@ -119,6 +112,17 @@
           ],
           'includes': ['../../../platform2/common-mk/generate-dbus-proxies.gypi'],
         },
+        {
+          'action_name': 'update_engine-dbus-network_proxy-client',
+          'variables': {
+            'mock_output_file': 'include/network_proxy/dbus-proxy-mocks.h',
+            'proxy_output_file': 'include/network_proxy/dbus-proxies.h'
+          },
+          'sources': [
+            'dbus_bindings/org.chromium.NetworkProxyService.dbus-xml',
+          ],
+          'includes': ['../../../platform2/common-mk/generate-dbus-proxies.gypi'],
+        },
       ],
     },
     # The payload application component and common dependencies.
@@ -133,7 +137,6 @@
       'variables': {
         'exported_deps': [
           'libcrypto',
-          'libimgpatch',
           'xz-embedded',
         ],
         'deps': ['<@(exported_deps)'],
@@ -152,6 +155,7 @@
           ],
         },
         'libraries': [
+          '-lbspatch',
           '-lbz2',
           '-lrt',
         ],
@@ -257,7 +261,6 @@
         'dbus_service.cc',
         'hardware_chromeos.cc',
         'image_properties_chromeos.cc',
-        'libcros_proxy.cc',
         'libcurl_http_fetcher.cc',
         'metrics.cc',
         'metrics_utils.cc',
@@ -287,19 +290,8 @@
         'update_manager/state_factory.cc',
         'update_manager/update_manager.cc',
         'update_status_utils.cc',
-        'weave_service_factory.cc',
       ],
       'conditions': [
-        ['USE_buffet == 1', {
-          'sources': [
-            'weave_service.cc',
-          ],
-          'variables': {
-            'exported_deps': [
-              'libweave-<(libbase_ver)',
-            ],
-          },
-        }],
         ['USE_libcros == 1', {
           'dependencies': [
             'update_engine-other-dbus-proxies',
diff --git a/update_manager/chromeos_policy.cc b/update_manager/chromeos_policy.cc
index 80ff601..81a169f 100644
--- a/update_manager/chromeos_policy.cc
+++ b/update_manager/chromeos_policy.cc
@@ -246,9 +246,9 @@
       }
 
       result->target_version_prefix = *kiosk_required_platform_version_p;
-      LOG(INFO) << "Allow kiosk app to control Chrome version policy is set,"
-                << ", target version is "
-                << (kiosk_required_platform_version_p
+      LOG(INFO) << "Allow kiosk app to control Chrome version policy is set, "
+                << "target version is "
+                << (!kiosk_required_platform_version_p->empty()
                         ? *kiosk_required_platform_version_p
                         : std::string("latest"));
     } else {
diff --git a/update_manager/evaluation_context.cc b/update_manager/evaluation_context.cc
index 63f7d9b..98238f2 100644
--- a/update_manager/evaluation_context.cc
+++ b/update_manager/evaluation_context.cc
@@ -19,10 +19,12 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include <base/bind.h>
 #include <base/json/json_writer.h>
 #include <base/location.h>
+#include <base/memory/ptr_util.h>
 #include <base/strings/string_util.h>
 #include <base/values.h>
 
@@ -227,13 +229,13 @@
 }
 
 string EvaluationContext::DumpContext() const {
-  base::DictionaryValue* variables = new base::DictionaryValue();
+  auto variables = base::MakeUnique<base::DictionaryValue>();
   for (auto& it : value_cache_) {
     variables->SetString(it.first->GetName(), it.second.ToString());
   }
 
   base::DictionaryValue value;
-  value.Set("variables", variables);  // Adopts |variables|.
+  value.Set("variables", std::move(variables));
   value.SetString(
       "evaluation_start_wallclock",
       chromeos_update_engine::utils::ToString(evaluation_start_wallclock_));
diff --git a/update_manager/real_system_provider.cc b/update_manager/real_system_provider.cc
index 44d5566..9b968ca 100644
--- a/update_manager/real_system_provider.cc
+++ b/update_manager/real_system_provider.cc
@@ -20,11 +20,11 @@
 #include <base/callback.h>
 #include <base/logging.h>
 #include <base/time/time.h>
+#if USE_LIBCROS
+#include <libcros/dbus-proxies.h>
+#endif
 
 #include "update_engine/common/utils.h"
-#if USE_LIBCROS
-#include "update_engine/libcros_proxy.h"
-#endif
 #include "update_engine/update_manager/generic_variables.h"
 #include "update_engine/update_manager/variable.h"
 
@@ -126,9 +126,8 @@
     string* required_platform_version) {
 #if USE_LIBCROS
   brillo::ErrorPtr error;
-  if (!libcros_proxy_->service_interface_proxy()
-           ->GetKioskAppRequiredPlatformVersion(required_platform_version,
-                                                &error)) {
+  if (!libcros_proxy_->GetKioskAppRequiredPlatformVersion(
+          required_platform_version, &error)) {
     LOG(WARNING) << "Failed to get kiosk required platform version";
     required_platform_version->clear();
     return false;
diff --git a/update_manager/real_system_provider.h b/update_manager/real_system_provider.h
index 083943b..a62e1ae 100644
--- a/update_manager/real_system_provider.h
+++ b/update_manager/real_system_provider.h
@@ -24,18 +24,21 @@
 #include "update_engine/common/hardware_interface.h"
 #include "update_engine/update_manager/system_provider.h"
 
-namespace chromeos_update_engine {
-class LibCrosProxy;
-}
+namespace org {
+namespace chromium {
+class LibCrosServiceInterfaceProxyInterface;
+}  // namespace chromium
+}  // namespace org
 
 namespace chromeos_update_manager {
 
 // SystemProvider concrete implementation.
 class RealSystemProvider : public SystemProvider {
  public:
-  RealSystemProvider(chromeos_update_engine::HardwareInterface* hardware,
-                     chromeos_update_engine::BootControlInterface* boot_control,
-                     chromeos_update_engine::LibCrosProxy* libcros_proxy)
+  RealSystemProvider(
+      chromeos_update_engine::HardwareInterface* hardware,
+      chromeos_update_engine::BootControlInterface* boot_control,
+      org::chromium::LibCrosServiceInterfaceProxyInterface* libcros_proxy)
       : hardware_(hardware),
         boot_control_(boot_control),
         libcros_proxy_(libcros_proxy) {}
@@ -75,7 +78,8 @@
 
   chromeos_update_engine::HardwareInterface* const hardware_;
   chromeos_update_engine::BootControlInterface* const boot_control_;
-  chromeos_update_engine::LibCrosProxy* const libcros_proxy_ ALLOW_UNUSED_TYPE;
+  org::chromium::LibCrosServiceInterfaceProxyInterface* const libcros_proxy_
+      ALLOW_UNUSED_TYPE;
 
   DISALLOW_COPY_AND_ASSIGN(RealSystemProvider);
 };
diff --git a/update_manager/real_system_provider_unittest.cc b/update_manager/real_system_provider_unittest.cc
index c997ad8..821a6cc 100644
--- a/update_manager/real_system_provider_unittest.cc
+++ b/update_manager/real_system_provider_unittest.cc
@@ -29,7 +29,6 @@
 #if USE_LIBCROS
 #include "libcros/dbus-proxies.h"
 #include "libcros/dbus-proxy-mocks.h"
-#include "update_engine/libcros_proxy.h"
 
 using org::chromium::LibCrosServiceInterfaceProxyMock;
 #endif  // USE_LIBCROS
@@ -51,19 +50,14 @@
  protected:
   void SetUp() override {
 #if USE_LIBCROS
-    service_interface_mock_ = new LibCrosServiceInterfaceProxyMock();
-    libcros_proxy_.reset(new chromeos_update_engine::LibCrosProxy(
-        brillo::make_unique_ptr(service_interface_mock_),
-        unique_ptr<
-            org::chromium::
-                UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface>()));
-    ON_CALL(*service_interface_mock_,
+    libcros_proxy_mock_.reset(new LibCrosServiceInterfaceProxyMock());
+    ON_CALL(*libcros_proxy_mock_,
             GetKioskAppRequiredPlatformVersion(_, _, _))
         .WillByDefault(
             DoAll(SetArgPointee<0>(kRequiredPlatformVersion), Return(true)));
 
     provider_.reset(new RealSystemProvider(
-        &fake_hardware_, &fake_boot_control_, libcros_proxy_.get()));
+        &fake_hardware_, &fake_boot_control_, libcros_proxy_mock_.get()));
 #else
     provider_.reset(
         new RealSystemProvider(&fake_hardware_, &fake_boot_control_, nullptr));
@@ -76,11 +70,7 @@
   unique_ptr<RealSystemProvider> provider_;
 
 #if USE_LIBCROS
-  // Local pointers to the mocks. The instances are owned by the
-  // |libcros_proxy_|.
-  LibCrosServiceInterfaceProxyMock* service_interface_mock_;
-
-  unique_ptr<chromeos_update_engine::LibCrosProxy> libcros_proxy_;
+  unique_ptr<LibCrosServiceInterfaceProxyMock> libcros_proxy_mock_;
 #endif  // USE_LIBCROS
 };
 
@@ -109,7 +99,7 @@
 }
 
 TEST_F(UmRealSystemProviderTest, KioskRequiredPlatformVersionFailure) {
-  EXPECT_CALL(*service_interface_mock_,
+  EXPECT_CALL(*libcros_proxy_mock_,
               GetKioskAppRequiredPlatformVersion(_, _, _))
       .WillOnce(Return(false));
 
@@ -119,14 +109,14 @@
 
 TEST_F(UmRealSystemProviderTest,
        KioskRequiredPlatformVersionRecoveryFromFailure) {
-  EXPECT_CALL(*service_interface_mock_,
+  EXPECT_CALL(*libcros_proxy_mock_,
               GetKioskAppRequiredPlatformVersion(_, _, _))
       .WillOnce(Return(false));
   UmTestUtils::ExpectVariableNotSet(
       provider_->var_kiosk_required_platform_version());
-  testing::Mock::VerifyAndClearExpectations(service_interface_mock_);
+  testing::Mock::VerifyAndClearExpectations(libcros_proxy_mock_.get());
 
-  EXPECT_CALL(*service_interface_mock_,
+  EXPECT_CALL(*libcros_proxy_mock_,
               GetKioskAppRequiredPlatformVersion(_, _, _))
       .WillOnce(
           DoAll(SetArgPointee<0>(kRequiredPlatformVersion), Return(true)));
diff --git a/update_manager/state_factory.cc b/update_manager/state_factory.cc
index 2b3ce63..70fc80b 100644
--- a/update_manager/state_factory.cc
+++ b/update_manager/state_factory.cc
@@ -47,7 +47,7 @@
 
 State* DefaultStateFactory(
     policy::PolicyProvider* policy_provider,
-    chromeos_update_engine::LibCrosProxy* libcros_proxy,
+    org::chromium::LibCrosServiceInterfaceProxyInterface* libcros_proxy,
     chromeos_update_engine::SystemState* system_state) {
   chromeos_update_engine::ClockInterface* const clock = system_state->clock();
   unique_ptr<RealConfigProvider> config_provider(
diff --git a/update_manager/state_factory.h b/update_manager/state_factory.h
index f1b576c..689684a 100644
--- a/update_manager/state_factory.h
+++ b/update_manager/state_factory.h
@@ -20,9 +20,11 @@
 #include "update_engine/system_state.h"
 #include "update_engine/update_manager/state.h"
 
-namespace chromeos_update_engine {
-class LibCrosProxy;
-}
+namespace org {
+namespace chromium {
+class LibCrosServiceInterfaceProxyInterface;
+}  // namespace chromium
+}  // namespace org
 
 namespace chromeos_update_manager {
 
@@ -33,7 +35,7 @@
 // to initialize.
 State* DefaultStateFactory(
     policy::PolicyProvider* policy_provider,
-    chromeos_update_engine::LibCrosProxy* libcros_proxy,
+    org::chromium::LibCrosServiceInterfaceProxyInterface* libcros_proxy,
     chromeos_update_engine::SystemState* system_state);
 
 }  // namespace chromeos_update_manager
diff --git a/update_status_utils.cc b/update_status_utils.cc
index 9685853..ff039b8 100644
--- a/update_status_utils.cc
+++ b/update_status_utils.cc
@@ -20,21 +20,6 @@
 
 using update_engine::UpdateStatus;
 
-namespace {
-
-const char kWeaveStatusIdle[] = "idle";
-const char kWeaveStatusCheckingForUpdate[] = "checkingForUpdate";
-const char kWeaveStatusUpdateAvailable[] = "updateAvailable";
-const char kWeaveStatusDownloading[] = "downloading";
-const char kWeaveStatusVerifying[] = "verifying";
-const char kWeaveStatusFinalizing[] = "finalizing";
-const char kWeaveStatusUpdatedNeedReboot[] = "updatedNeedReboot";
-const char kWeaveStatusReportingErrorEvent[] = "reportingErrorEvent";
-const char kWeaveStatusAttemptingRollback[] = "attemptingRollback";
-const char kWeaveStatusDisabled[] = "disabled";
-
-}  // namespace
-
 namespace chromeos_update_engine {
 
 const char* UpdateStatusToString(const UpdateStatus& status) {
@@ -65,34 +50,6 @@
   return nullptr;
 }
 
-const char* UpdateStatusToWeaveStatus(const UpdateStatus& status) {
-  switch (status) {
-    case UpdateStatus::IDLE:
-      return kWeaveStatusIdle;
-    case UpdateStatus::CHECKING_FOR_UPDATE:
-      return kWeaveStatusCheckingForUpdate;
-    case UpdateStatus::UPDATE_AVAILABLE:
-      return kWeaveStatusUpdateAvailable;
-    case UpdateStatus::DOWNLOADING:
-      return kWeaveStatusDownloading;
-    case UpdateStatus::VERIFYING:
-      return kWeaveStatusVerifying;
-    case UpdateStatus::FINALIZING:
-      return kWeaveStatusFinalizing;
-    case UpdateStatus::UPDATED_NEED_REBOOT:
-      return kWeaveStatusUpdatedNeedReboot;
-    case UpdateStatus::REPORTING_ERROR_EVENT:
-      return kWeaveStatusReportingErrorEvent;
-    case UpdateStatus::ATTEMPTING_ROLLBACK:
-      return kWeaveStatusAttemptingRollback;
-    case UpdateStatus::DISABLED:
-      return kWeaveStatusDisabled;
-  }
-
-  NOTREACHED();
-  return nullptr;
-}
-
 bool StringToUpdateStatus(const std::string& s,
                           UpdateStatus* status) {
   if (s == update_engine::kUpdateStatusIdle) {
diff --git a/update_status_utils.h b/update_status_utils.h
index 9d85144..30ae53b 100644
--- a/update_status_utils.h
+++ b/update_status_utils.h
@@ -25,10 +25,6 @@
 
 const char* UpdateStatusToString(const update_engine::UpdateStatus& status);
 
-// Convert the UpdateStatus |status| to the string reported in the weave status.
-const char* UpdateStatusToWeaveStatus(
-    const update_engine::UpdateStatus& status);
-
 bool StringToUpdateStatus(const std::string& update_status_as_string,
                           update_engine::UpdateStatus* status);
 
diff --git a/weave_service.cc b/weave_service.cc
deleted file mode 100644
index 0a145e4..0000000
--- a/weave_service.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "update_engine/weave_service.h"
-
-#include <cmath>
-#include <string>
-
-#include <base/bind.h>
-#include <brillo/errors/error.h>
-#include <brillo/message_loops/message_loop.h>
-
-#include "update_engine/update_status_utils.h"
-
-using std::string;
-
-namespace {
-
-const char kWeaveComponent[] = "updater";
-const char kWeaveTrait[] = "_updater";
-
-}  // namespace
-
-namespace chromeos_update_engine {
-
-bool WeaveService::Init(DelegateInterface* delegate) {
-  delegate_ = delegate;
-  weave_service_subscription_ = weaved::Service::Connect(
-      brillo::MessageLoop::current(),
-      base::Bind(&WeaveService::OnWeaveServiceConnected,
-                 base::Unretained(this)));
-  return true;
-}
-
-void WeaveService::OnWeaveServiceConnected(
-    const std::weak_ptr<weaved::Service>& service) {
-  weave_service_ = service;
-  auto weave_service = weave_service_.lock();
-  if (!weave_service)
-    return;
-
-  weave_service->AddComponent(kWeaveComponent, {kWeaveTrait}, nullptr);
-  weave_service->AddCommandHandler(
-      kWeaveComponent, kWeaveTrait, "checkForUpdates",
-      base::Bind(&WeaveService::OnCheckForUpdates, base::Unretained(this)));
-  weave_service->AddCommandHandler(
-      kWeaveComponent, kWeaveTrait, "trackChannel",
-      base::Bind(&WeaveService::OnTrackChannel, base::Unretained(this)));
-  UpdateWeaveState();
-}
-
-void WeaveService::SendStatusUpdate(int64_t /* last_checked_time */,
-                                    double /* progress */,
-                                    update_engine::UpdateStatus /* status */,
-                                    const string& /* new_version */,
-                                    int64_t /* new_size */) {
-  // We query the Weave
-  UpdateWeaveState();
-}
-
-void WeaveService::SendChannelChangeUpdate(
-    const string& /* tracking_channel */) {
-  UpdateWeaveState();
-}
-
-void WeaveService::UpdateWeaveState() {
-  auto weave_service = weave_service_.lock();
-  if (!weave_service || !delegate_)
-    return;
-
-  int64_t last_checked_time;
-  double progress;
-  update_engine::UpdateStatus update_status;
-  string current_channel;
-  string tracking_channel;
-
-  if (!delegate_->GetWeaveState(&last_checked_time,
-                                &progress,
-                                &update_status,
-                                &current_channel,
-                                &tracking_channel))
-    return;
-
-  // Round to progress to 1% (0.01) to avoid excessive and meaningless state
-  // changes.
-  progress = std::floor(progress * 100.) / 100.;
-
-  base::DictionaryValue state;
-  state.SetString("_updater.currentChannel", current_channel);
-  state.SetString("_updater.trackingChannel", tracking_channel);
-  state.SetString("_updater.status", UpdateStatusToWeaveStatus(update_status));
-  state.SetDouble("_updater.progress", progress);
-  state.SetDouble("_updater.lastUpdateCheckTimestamp",
-                  static_cast<double>(last_checked_time));
-
-  if (!weave_service->SetStateProperties(kWeaveComponent, state, nullptr)) {
-    LOG(ERROR) << "Failed to update _updater state.";
-  }
-}
-
-void WeaveService::OnCheckForUpdates(std::unique_ptr<weaved::Command> command) {
-  brillo::ErrorPtr error;
-  if (!delegate_->OnCheckForUpdates(&error)) {
-    command->AbortWithCustomError(error.get(), nullptr);
-    return;
-  }
-  command->Complete({}, nullptr);
-}
-
-void WeaveService::OnTrackChannel(std::unique_ptr<weaved::Command> command) {
-  string channel = command->GetParameter<string>("channel");
-  brillo::ErrorPtr error;
-  if (!delegate_->OnTrackChannel(channel, &error)) {
-    command->AbortWithCustomError(error.get(), nullptr);
-    return;
-  }
-  command->Complete({}, nullptr);
-}
-
-}  // namespace chromeos_update_engine
diff --git a/weave_service.h b/weave_service.h
deleted file mode 100644
index 5a3aff3..0000000
--- a/weave_service.h
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef UPDATE_ENGINE_WEAVE_SERVICE_H_
-#define UPDATE_ENGINE_WEAVE_SERVICE_H_
-
-#include <memory>
-#include <string>
-
-#include <base/memory/weak_ptr.h>
-#include <libweaved/command.h>
-#include <libweaved/service.h>
-
-#include "update_engine/weave_service_interface.h"
-
-namespace chromeos_update_engine {
-
-class WeaveService : public WeaveServiceInterface {
- public:
-  WeaveService() = default;
-  ~WeaveService() override = default;
-
-  bool Init(DelegateInterface* delegate);
-
-  // ServiceObserverInterface overrides.
-  void SendStatusUpdate(int64_t last_checked_time,
-                        double progress,
-                        update_engine::UpdateStatus status,
-                        const std::string& new_version,
-                        int64_t new_size) override;
-  void SendChannelChangeUpdate(const std::string& tracking_channel) override;
-  void SendPayloadApplicationComplete(ErrorCode error_code) override {}
-
- private:
-  // Force a weave update.
-  void UpdateWeaveState();
-
-  void OnWeaveServiceConnected(const std::weak_ptr<weaved::Service>& service);
-
-  // Weave command handlers. These are called from the message loop whenever a
-  // command is received and dispatch the synchronous call to the |delegate_|.
-  void OnCheckForUpdates(std::unique_ptr<weaved::Command> cmd);
-  void OnTrackChannel(std::unique_ptr<weaved::Command> cmd);
-
-  WeaveServiceInterface::DelegateInterface* delegate_{nullptr};
-
-  std::unique_ptr<weaved::Service::Subscription> weave_service_subscription_;
-  std::weak_ptr<weaved::Service> weave_service_;
-};
-
-}  // namespace chromeos_update_engine
-
-#endif  // UPDATE_ENGINE_WEAVE_SERVICE_H_
diff --git a/weave_service_factory.cc b/weave_service_factory.cc
deleted file mode 100644
index 24b9b79..0000000
--- a/weave_service_factory.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "update_engine/weave_service_factory.h"
-
-#if USE_WEAVE
-#include "update_engine/weave_service.h"
-#endif
-
-namespace chromeos_update_engine {
-
-std::unique_ptr<WeaveServiceInterface> ConstructWeaveService(
-    WeaveServiceInterface::DelegateInterface* delegate) {
-  std::unique_ptr<WeaveServiceInterface> result;
-  if (!delegate)
-    return result;
-
-#if USE_WEAVE
-  WeaveService* weave_service = new WeaveService();
-  result.reset(weave_service);
-  if (!weave_service->Init(delegate))
-    result.reset();
-#endif
-  return result;
-}
-
-}  // namespace chromeos_update_engine
diff --git a/weave_service_factory.h b/weave_service_factory.h
deleted file mode 100644
index 7b129ab..0000000
--- a/weave_service_factory.h
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
-#define UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
-
-#include <memory>
-
-#include <base/memory/ref_counted.h>
-
-#include "update_engine/weave_service_interface.h"
-
-namespace chromeos_update_engine {
-
-// Create a new WeaveServiceInterface instance. In case of error or when weaved
-// is disabled, returns an empty pointer.
-std::unique_ptr<WeaveServiceInterface> ConstructWeaveService(
-    WeaveServiceInterface::DelegateInterface* delegate);
-
-}  // namespace chromeos_update_engine
-
-#endif  // UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
diff --git a/weave_service_interface.h b/weave_service_interface.h
deleted file mode 100644
index a7e603e..0000000
--- a/weave_service_interface.h
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
-#define UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
-
-#include <string>
-
-#include <brillo/errors/error.h>
-
-#include "update_engine/client_library/include/update_engine/update_status.h"
-#include "update_engine/service_observer_interface.h"
-
-namespace chromeos_update_engine {
-
-// A WeaveServiceInterface instance allows to register the daemon with weaved,
-// handle commands and update the weave status. This class only handles the
-// registration with weaved and the connection, the actual work to handle the
-// commands is implemented by the DelegateInterface, which will be called from
-// this class.
-class WeaveServiceInterface : public ServiceObserverInterface {
- public:
-  // The delegate class that actually handles the command execution from
-  class DelegateInterface {
-   public:
-    virtual ~DelegateInterface() = default;
-
-    virtual bool OnCheckForUpdates(brillo::ErrorPtr* error) = 0;
-
-    virtual bool OnTrackChannel(const std::string& channel,
-                                brillo::ErrorPtr* error) = 0;
-
-    // Return the current status.
-    virtual bool GetWeaveState(int64_t* last_checked_time,
-                               double* progress,
-                               update_engine::UpdateStatus* update_status,
-                               std::string* current_channel,
-                               std::string* tracking_channel) = 0;
-  };
-
-  virtual ~WeaveServiceInterface() = default;
-
- protected:
-  WeaveServiceInterface() = default;
-};
-
-}  // namespace chromeos_update_engine
-
-#endif  // UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
diff --git a/weaved/traits/updater.json b/weaved/traits/updater.json
deleted file mode 100644
index 52b1a55..0000000
--- a/weaved/traits/updater.json
+++ /dev/null
@@ -1,52 +0,0 @@
-{
-  "_updater": {
-    "commands": {
-      "checkForUpdates": {
-        "minimalRole": "manager",
-        "parameters": {}
-      },
-      "trackChannel": {
-        "minimalRole": "manager",
-        "parameters": {
-          "channel": {
-            "type": "string",
-            "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
-          }
-        }
-      }
-    },
-    "state": {
-      "currentChannel": {
-        "type": "string",
-        "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
-      },
-      "trackingChannel": {
-        "type": "string",
-        "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
-      },
-      "status": {
-        "type": "string",
-        "enum": [
-          "idle",
-          "checkingForUpdate",
-          "updateAvailable",
-          "downloading",
-          "verifying",
-          "finalizing",
-          "updatedNeedReboot",
-          "reportingErrorEvent",
-          "attemptingRollback",
-          "disabled"
-        ]
-      },
-      "progress": {
-        "type": "number",
-        "minimum": 0,
-        "maximum": 1
-      },
-      "lastUpdateCheckTimestamp": {
-        "type": "number"
-      }
-    }
-  }
-}