HealthMonitor: improve watchdog interface

Test: build
Change-Id: I922acacb99c58955d4d1eaaafce337d72dc4eb5d
diff --git a/stream-servers/RenderThread.cpp b/stream-servers/RenderThread.cpp
index 3429736..664c8c6 100644
--- a/stream-servers/RenderThread.cpp
+++ b/stream-servers/RenderThread.cpp
@@ -430,10 +430,11 @@
                     {{"renderthread_guest_process", tInfo.m_processName.value()}});
                 processName = tInfo.m_processName.value().c_str();
             }
-            HealthWatchdog watchdog(FrameBuffer::getFB()->getHealthMonitor(),
-                                    WATCHDOG_DATA("RenderThread decode operation",
-                                                  EventHangMetadata::HangType::kRenderThread,
-                                                  std::move(renderThreadData)));
+            auto watchdog = WATCHDOG_BUILDER(FrameBuffer::getFB()->getHealthMonitor(),
+                                             "RenderThread decode operation")
+                                .setHangType(EventHangMetadata::HangType::kRenderThread)
+                                .setAnnotations(std::move(renderThreadData))
+                                .build();
 
             if (!seqnoPtr && tInfo.m_puid) {
                 seqnoPtr = FrameBuffer::getFB()->getProcessSequenceNumberPtr(tInfo.m_puid);
diff --git a/stream-servers/SyncThread.cpp b/stream-servers/SyncThread.cpp
index b51ca30..9b0897a 100644
--- a/stream-servers/SyncThread.cpp
+++ b/stream-servers/SyncThread.cpp
@@ -272,9 +272,10 @@
     std::unique_ptr<std::unordered_map<std::string, std::string>> syncThreadData =
         std::make_unique<std::unordered_map<std::string, std::string>>();
     syncThreadData->insert({{"syncthread_cmd_desc", command.mDescription}});
-    HealthWatchdog watchdog(mHealthMonitor, WATCHDOG_DATA("SyncThread task execution",
-                                                          EventHangMetadata::HangType::kSyncThread,
-                                                          std::move(syncThreadData)));
+    auto watchdog = WATCHDOG_BUILDER(mHealthMonitor, "SyncThread task execution")
+                        .setHangType(EventHangMetadata::HangType::kSyncThread)
+                        .setAnnotations(std::move(syncThreadData))
+                        .build();
     command.mTask(workerId);
 }
 
diff --git a/stream-servers/vulkan/VkDecoder.cpp b/stream-servers/vulkan/VkDecoder.cpp
index 3e5aff5..743bef3 100644
--- a/stream-servers/vulkan/VkDecoder.cpp
+++ b/stream-servers/vulkan/VkDecoder.cpp
@@ -48,7 +48,6 @@
 #include "host-common/logging.h"
 #include "stream-servers/IOStream.h"
 
-using emugl::HealthWatchdog;
 using emugl::vkDispatch;
 
 using namespace goldfish_vk;
@@ -137,26 +136,25 @@
             *readStreamPtrPtr += sizeof(uint32_t);
             if (seqnoPtr && !m_forSnapshotLoad) {
                 {
-                    HealthWatchdog watchdog(
-                        healthMonitor,
-                        WATCHDOG_DATA("RenderThread seqno loop - 3 second timeout",
-                                      EventHangMetadata::HangType::kRenderThread, nullptr),
-                        /* Data gathered if this hangs*/
-                        std::function<std::unique_ptr<EventHangMetadata::HangAnnotations>()>([=]() {
-                            std::unique_ptr<EventHangMetadata::HangAnnotations> annotations =
-                                std::make_unique<EventHangMetadata::HangAnnotations>();
-                            annotations->insert({{"seqno", std::to_string(seqno)},
-                                                 {"seqnoPtr", std::to_string(__atomic_load_n(
-                                                                  seqnoPtr, __ATOMIC_SEQ_CST))},
-                                                 {"opcode", std::to_string(opcode)},
-                                                 {"buffer_length", std::to_string(len)}});
-                            if (processName) {
-                                annotations->insert(
-                                    {{"renderthread_guest_process", std::string(processName)}});
-                            }
-                            return std::move(annotations);
-                        }),
-                        3000 /* 3 seconds. Should be plenty*/);
+                    auto watchdog =
+                        WATCHDOG_BUILDER(healthMonitor, "RenderThread seqno loop")
+                            .setHangType(EventHangMetadata::HangType::kRenderThread)
+                            /* Data gathered if this hangs*/
+                            .setOnHangCallback([=]() {
+                                auto annotations =
+                                    std::make_unique<EventHangMetadata::HangAnnotations>();
+                                annotations->insert({{"seqno", std::to_string(seqno)},
+                                                     {"seqnoPtr", std::to_string(__atomic_load_n(
+                                                                      seqnoPtr, __ATOMIC_SEQ_CST))},
+                                                     {"opcode", std::to_string(opcode)},
+                                                     {"buffer_length", std::to_string(len)}});
+                                if (processName) {
+                                    annotations->insert(
+                                        {{"renderthread_guest_process", std::string(processName)}});
+                                }
+                                return std::move(annotations);
+                            })
+                            .build();
                     while ((seqno - __atomic_load_n(seqnoPtr, __ATOMIC_SEQ_CST) != 1)) {
 #if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)))
                         _mm_pause();