Initial publish

1 files changed, 1160 insertions, 0 deletions

diff --git a/wpd/WpdWudfSampleDriver/WpdObjectManagement.cpp b/wpd/WpdWudfSampleDriver/WpdObjectManagement.cpp
new file mode 100644
index 00000000..9c3d22b2
--- /dev/null
+++ b/wpd/WpdWudfSampleDriver/WpdObjectManagement.cpp
@@ -0,0 +1,1160 @@
+#include "stdafx.h"
+#include "WpdObjectManagement.tmh"
+
+WpdObjectManagement::WpdObjectManagement()
+{
+
+}
+
+WpdObjectManagement::~WpdObjectManagement()
+{
+
+}
+
+HRESULT WpdObjectManagement::Initialize(_In_    FakeDevice *pFakeDevice)
+{
+    HRESULT hr = S_OK;
+
+    if(pFakeDevice == NULL)
+    {
+        hr = E_POINTER;
+        CHECK_HR(hr, "Cannot have NULL parameter");
+        return hr;
+    }
+
+    m_pFakeDevice = pFakeDevice;
+
+    return hr;
+}
+
+HRESULT WpdObjectManagement::DispatchWpdMessage(
+    _In_    REFPROPERTYKEY          Command,
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT hr = S_OK;
+
+    if (hr == S_OK)
+    {
+        if (Command.fmtid != WPD_CATEGORY_OBJECT_MANAGEMENT)
+        {
+            hr = E_INVALIDARG;
+            CHECK_HR(hr, "This object does not support this command category %ws",CComBSTR(Command.fmtid));
+        }
+    }
+
+    if (hr == S_OK)
+    {
+        if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS.pid)
+        {
+            hr = OnDelete(pParams, pResults);
+            CHECK_HR(hr, "Failed to delete object");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_ONLY.pid)
+        {
+            hr = OnCreateObjectWithPropertiesOnly(pParams, pResults);
+            CHECK_HR(hr, "Failed to create object");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_AND_DATA.pid)
+        {
+            hr = OnCreateObjectWithPropertiesAndData(pParams, pResults);
+            CHECK_HR(hr, "Failed to create object");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_WRITE_OBJECT_DATA.pid)
+        {
+            hr = OnWriteObjectData(pParams, pResults);
+            CHECK_HR(hr, "Failed to write object data");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT.pid)
+        {
+            hr = OnCommit(pParams, pResults);
+            CHECK_HR(hr, "Failed to commit object");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_REVERT_OBJECT.pid)
+        {
+            hr = OnRevert(pParams, pResults);
+            CHECK_HR(hr, "Failed to revert object");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_MOVE_OBJECTS.pid)
+        {
+            hr = OnMove(pParams, pResults);
+            CHECK_HR(hr, "Failed to Move objects");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_COPY_OBJECTS.pid)
+        {
+            hr = OnCopy(pParams, pResults);
+            CHECK_HR(hr, "Failed to Copy objects");
+        }
+        else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_UPDATE_OBJECT_WITH_PROPERTIES_AND_DATA.pid)
+        {
+            hr = OnUpdateObjectWithPropertiesAndData(pParams, pResults);
+            CHECK_HR(hr, "Failed to update object");
+        }
+        else
+        {
+            hr = E_NOTIMPL;
+            CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
+        }
+    }
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS: the ObjectIDs, indicating which objects to delete.  These may
+ *      contain children.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS: Flag parameter indicating delete options. Must be one
+ *                  of the following:
+ *                 - PORTABLE_DEVICE_DELETE_NO_RECURSION - Deletes the
+ *                          object only.  This should fail if children exist.
+ *                 - PORTABLE_DEVICE_DELETE_WITH_RECURSION - Deletes this
+ *                          object and all children.
+ *
+ *  The driver should:
+ *  - If the flag is PORTABLE_DEVICE_DELETE_NO_RECURSION the driver should delete the
+ *    specified object only.  If the object still has children the driver should not delete
+ *    the object and instead return HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION).
+ *  - If the flag is PORTABLE_DEVICE_DELETE_WITH_RECURSION the driver should delete the
+ *    specified object and all of its children.
+ *  - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS.  It contains an IPortableDevicePropVariantCollection of
+ *    VT_ERROR values indicating the success or failure of the operation for that element.
+ *    Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
+ *  - The driver should return:
+ *      - S_OK if all objects were deleted successfully.
+ *      - S_FALSE if any object delete failed.
+ *      - An error return indicates that the driver did not delete any objects, and
+ *        WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS is ignored.
+ */
+HRESULT WpdObjectManagement::OnDelete(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT hr              = S_OK;
+    DWORD   dwOptions       = PORTABLE_DEVICE_DELETE_NO_RECURSION;
+    BOOL    bDeleteFailed   = FALSE;
+    CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
+    CComPtr<IPortableDevicePropVariantCollection> pDeleteResults;
+    CComPtr<IPortableDeviceValues> pEventParams;
+    VARTYPE vt              = VT_EMPTY;
+
+    if (hr == S_OK)
+    {
+        hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+    }
+
+    // Ensure that this is a collection of VT_LPWSTR
+    if (hr == S_OK)
+    {
+        hr = pObjectIDs->GetType(&vt);
+        CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+        if (hr == S_OK)
+        {
+            if (vt != VT_LPWSTR)
+            {
+                hr = E_INVALIDARG;
+                CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
+            }
+        }
+    }
+
+    if (hr == S_OK)
+    {
+        hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS, &dwOptions);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS");
+    }
+
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDevicePropVariantCollection,
+                              (VOID**) &pDeleteResults);
+        CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
+    }
+
+
+    if (hr == S_OK)
+    {
+        DWORD   cObjects    = 0;
+        // Loop through the object list and attempt to delete
+        hr = pObjectIDs->GetCount(&cObjects);
+        CHECK_HR(hr, "Failed to get number of objects to delete");
+
+        if (hr == S_OK)
+        {
+            for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
+            {
+                HRESULT hrTemp = S_OK;
+                PROPVARIANT pv = {0};
+
+                PropVariantInit(&pv);
+                // Get the next Object to delete
+                hr = pObjectIDs->GetAt(dwIndex, &pv);
+                CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
+                if (hr == S_OK)
+                {
+                    pEventParams = NULL;
+                    // Get the object properties used for sending the event.  Ignore errors (these are expected in some cases
+                    // e.g. app is sending object ID that doesn't exist), since this relates to the event, not the delete operation,
+                    // and we return results for the delete (an error posting the event is non-fatal).
+                    hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pv.pwszVal, &pEventParams);
+                    CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pv.pwszVal);
+
+                    HRESULT     hrDelete = S_OK;
+                    PROPVARIANT pvResult = {0};
+
+                    PropVariantInit(&pvResult);
+
+                    hrDelete = m_pFakeDevice->DeleteObject(dwOptions, pv.pwszVal);
+                    CHECK_HR(hrDelete, "Failed to delete object [%ws]", pv.pwszVal);
+
+                    if(FAILED(hrDelete))
+                    {
+                        bDeleteFailed = TRUE;
+                    }
+
+                    // Save this result
+                    pvResult.vt       = VT_ERROR;
+                    pvResult.scode    = hrDelete;
+                    hrTemp = pDeleteResults->Add(&pvResult);
+                    PropVariantClear(&pvResult);
+                    CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
+
+                    if ((hrDelete == S_OK) && (hrTemp == S_OK))
+                    {
+                        HRESULT hrEvent = S_OK;
+                        // Set the event-specific parameters
+                        hrEvent = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_REMOVED);
+                        CHECK_HR(hrEvent, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
+
+                        // Send the Event
+                        if (hrEvent == S_OK)
+                        {
+                            PostWpdEvent(pParams, pEventParams);
+                        }
+                    }
+                    PropVariantClear(&pv);
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+    // Set the results
+    if (hr == S_OK)
+    {
+        hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS, pDeleteResults);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS");
+    }
+
+    // If an object failed to delete, make sure we return S_FALSE
+    if ((hr == S_OK) && (bDeleteFailed))
+    {
+        hr = S_FALSE;
+    }
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_MOVE_OBJECTS
+ *  command.
+ *
+ * This command will move the specified objects to the destination folder.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS : the ObjectIDs, indicating which objects to move.  These may
+ *      be folder objects.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID: Indicates the destination folder for the move operation.
+ *
+ *  The driver should:
+ *  - Attempt to Move the object specified in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS to the folder specified in
+ *    WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID.
+ * - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS.  It contains an IportableDevicePropVariantCollection of
+ *   VT_ERROR values indicating the success or failure of the operation for that element.
+ *   Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
+ *  - The driver should return:
+ *      - S_OK if all objects were moved successfully.
+ *      - S_FALSE if any object move failed.
+ *      - An error return indicates that the driver did not move any objects, and
+ *        WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS is ignored.
+ */
+HRESULT WpdObjectManagement::OnMove(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT hr                    = S_OK;
+    LPWSTR  pszDestFolderObjectID = NULL;
+    CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
+    CComPtr<IPortableDevicePropVariantCollection> pMoveResults;
+    BOOL    bMoveFailed           = FALSE;
+    VARTYPE vt                    = VT_EMPTY;
+
+    if (hr == S_OK)
+    {
+        hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+    }
+
+    // Ensure that this is a collection of VT_LPWSTR
+    if (hr == S_OK)
+    {
+        hr = pObjectIDs->GetType(&vt);
+        CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+        if (hr == S_OK)
+        {
+            if (vt != VT_LPWSTR)
+            {
+                hr = E_INVALIDARG;
+                CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
+            }
+        }
+    }
+
+    if (hr == S_OK)
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID, &pszDestFolderObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID");
+    }
+
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDevicePropVariantCollection,
+                              (VOID**) &pMoveResults);
+        CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
+    }
+
+
+    if (hr == S_OK)
+    {
+        DWORD   cObjects    = 0;
+        // Loop through the object list and attempt to move
+        hr = pObjectIDs->GetCount(&cObjects);
+        CHECK_HR(hr, "Failed to get number of objects to move");
+
+        if (hr == S_OK)
+        {
+            for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
+            {
+                HRESULT hrTemp = S_OK;
+                PROPVARIANT pv = {0};
+
+                PropVariantInit(&pv);
+                // Get the next Object to move
+                hrTemp = pObjectIDs->GetAt(dwIndex, &pv);
+                CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
+                if (hrTemp == S_OK)
+                {
+                    // Move this object
+                    hrTemp = m_pFakeDevice->MoveObject(pv.pwszVal, pszDestFolderObjectID);
+                    CHECK_HR(hrTemp, "Failed to move object [%ws] to folder [%ws]", pv.pwszVal, pszDestFolderObjectID);
+
+                    if(FAILED(hrTemp))
+                    {
+                        bMoveFailed = TRUE;
+                    }
+
+                    PROPVARIANT pvResult = {0};
+
+                    PropVariantInit(&pvResult);
+
+                    // Save this result
+                    pvResult.vt       = VT_ERROR;
+                    pvResult.scode    = hrTemp;
+                    hrTemp = pMoveResults->Add(&pvResult);
+                    CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
+
+                    PropVariantClear(&pvResult);
+                }
+                PropVariantClear(&pv);
+            }
+        }
+    }
+
+    // Set the results
+    if (hr == S_OK)
+    {
+        hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS, pMoveResults);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS");
+    }
+
+    CoTaskMemFree(pszDestFolderObjectID);
+
+    // If an object failed to move, make sure we return S_FALSE
+    if ((hr == S_OK) && (bMoveFailed))
+    {
+        hr = S_FALSE;
+    }
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_COPY_OBJECTS
+ *  command.
+ *
+ * This command will copy the specified objects to the destination folder.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS : the ObjectIDs, indicating which objects to copy.  These may
+ *      be folder objects.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID: Indicates the destination folder for the copy operation.
+ *
+ *  The driver should:
+ *  - Attempt to copy the object specified in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS to the folder specified in
+ *    WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID.
+ * - Fill out the operation results in WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS.  It contains an IPortableDevicePropVariantCollection of
+ *   VT_ERROR values indicating the success or failure of the operation for that element.
+ *   Order is implicit, i.e. the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS corresponds to the first element of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS and so on.
+ *  - The driver should return:
+ *      - S_OK if all objects were copied successfully.
+ *      - S_FALSE if any object copy failed.
+ *      - An error return indicates that the driver did not copy any objects, and
+ *        WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS is ignored.
+ */
+HRESULT WpdObjectManagement::OnCopy(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT hr                    = S_OK;
+    LPWSTR  pszDestFolderObjectID = NULL;
+    CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
+    CComPtr<IPortableDevicePropVariantCollection> pCopyResults;
+    BOOL    bCopyFailed           = FALSE;
+    VARTYPE vt                    = VT_EMPTY;
+
+    hr = pParams->GetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS, &pObjectIDs);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+
+    // Ensure that this is a collection of VT_LPWSTR
+    if (SUCCEEDED(hr))
+    {
+        hr = pObjectIDs->GetType(&vt);
+        CHECK_HR(hr, "Failed to get the VARTYP of WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS");
+        if (hr == S_OK)
+        {
+            if (vt != VT_LPWSTR)
+            {
+                hr = E_INVALIDARG;
+                CHECK_HR(hr, "WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS is not a collection of VT_LPWSTR");
+            }
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID, &pszDestFolderObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDevicePropVariantCollection,
+                              (VOID**) &pCopyResults);
+        CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDevicePropVariantCollection");
+    }
+
+
+    if (SUCCEEDED(hr))
+    {
+        DWORD   cObjects    = 0;
+        // Loop through the object list and attempt to copy
+        hr = pObjectIDs->GetCount(&cObjects);
+        CHECK_HR(hr, "Failed to get number of objects to copy");
+
+        if (SUCCEEDED(hr))
+        {
+            for(DWORD dwIndex = 0; dwIndex < cObjects; dwIndex++)
+            {
+                CComPtr<IPortableDeviceValues> pEventParams;
+                LPWSTR  pszNewObjectID = NULL;
+                HRESULT hrTemp = S_OK;
+                PROPVARIANT pv = {0};
+
+                PropVariantInit(&pv);
+                // Get the next Object to copy
+                hrTemp = pObjectIDs->GetAt(dwIndex, &pv);
+                CHECK_HR(hr, "Failed to get next object id at index %d", dwIndex);
+                if (SUCCEEDED(hrTemp))
+                {
+                    // Copy this object
+                    hrTemp = m_pFakeDevice->CopyObject(pv.pwszVal, pszDestFolderObjectID, &pszNewObjectID);
+                    CHECK_HR(hrTemp, "Failed to copy object [%ws] to folder [%ws]", pv.pwszVal, pszDestFolderObjectID);
+
+                    if(FAILED(hrTemp))
+                    {
+                        bCopyFailed = TRUE;
+                    }
+
+                    PROPVARIANT pvResult = {0};
+
+                    PropVariantInit(&pvResult);
+
+                    // Save this result
+                    pvResult.vt       = VT_ERROR;
+                    pvResult.scode    = hrTemp;
+                    hrTemp = pCopyResults->Add(&pvResult);
+                    CHECK_HR(hrTemp, "Failed to add result for [%ws] to list of results", pv.pwszVal);
+
+                    PropVariantClear(&pvResult);
+
+                    if (SUCCEEDED(hrTemp))
+                    {
+                        // Send the event
+                        // Get the object properties used for sending the event
+                        hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pszNewObjectID, &pEventParams);
+                        CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pszNewObjectID);
+                        if (SUCCEEDED(hrTemp))
+                        {
+                            // Set the event-specific parameters
+                            hrTemp = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_ADDED);
+                            CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
+
+                            // Send the Event
+                            if (SUCCEEDED(hrTemp))
+                            {
+                                PostWpdEvent(pParams, pEventParams);
+                            }
+                        }
+                    }
+                }
+
+                if (pszNewObjectID != NULL)
+                {
+                    CoTaskMemFree(pszNewObjectID);
+                    pszNewObjectID = NULL;
+                }
+
+                PropVariantClear(&pv);
+            }
+        }
+    }
+
+    // Set the results
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetIPortableDevicePropVariantCollectionValue(WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS, pCopyResults);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS");
+    }
+
+    CoTaskMemFree(pszDestFolderObjectID);
+
+    // If an object failed to copy, make sure we return S_FALSE
+    if (SUCCEEDED(hr) && bCopyFailed)
+    {
+        hr = S_FALSE;
+    }
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_ONLY
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES: Contains an IPortableDeviceValues, describing
+ *      properties of the new object.  At the very least, it will contain:
+ *      -  WPD_OBJECT_NAME: The object name.
+ *      -  WPD_PARENT_ID: Identifies the parent object.  The object should be inserted as a child of
+ *         this parent (e.g. this would be the target directory in a file system based device).
+ *
+ *  The driver should:
+ *  - Create the object, and return its ID in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID.
+ */
+HRESULT WpdObjectManagement::OnCreateObjectWithPropertiesOnly(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT                         hr              = S_OK;
+    LPWSTR                          pszContext      = NULL;
+    CComPtr<IPortableDeviceValues>  pValues;
+    CComPtr<IPortableDeviceValues>  pEventParams;
+
+    // Get the Object Properties
+    hr = pParams->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES, &pValues);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES");
+
+    // Save the object to the device here.
+    if (SUCCEEDED(hr))
+    {
+        hr = m_pFakeDevice->SaveNewObject(pValues, &pszContext);
+        CHECK_HR(hr, "Failed to save new (properties only) object to device");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID, pszContext);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Send the event
+        HRESULT hrTemp = S_OK;
+        // Get the object properties used for sending the event
+        hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pszContext, &pEventParams);
+        CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pszContext);
+        if (SUCCEEDED(hrTemp))
+        {
+            // Set the event-specific parameters
+            hrTemp = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_ADDED);
+            CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
+
+            // Send the Event
+            if (SUCCEEDED(hrTemp))
+            {
+                PostWpdEvent(pParams, pEventParams);
+            }
+        }
+    }
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszContext);
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_AND_DATA
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES: Contains an IPortableDeviceValues, describing
+ *      properties of the new object.  At the very least, it will contain:
+ *      -  WPD_OBJECT_NAME: The object name.
+ *      -  WPD_PARENT_ID: Identifies the parent object.  The object should be inserted as a child of
+ *         this parent (e.g. this would be the target directory in a file system based device).
+ *      -  WPD_OBJECT_SIZE: The total size of the object data stream.
+ *      -  WPD_OBJECT_FORMAT: The format the object data stream.
+ *
+ *  The driver should:
+ *  - Create a context for this operation and return it in WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT.
+ *  - Return the optimal transfer buffer size in WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE.
+ */
+HRESULT WpdObjectManagement::OnCreateObjectWithPropertiesAndData(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT                         hr              = S_OK;
+    LPWSTR                          pszContext      = NULL;
+    LPWSTR                          pszObjectName   = NULL;
+    IUnknown*                       pContextMap     = NULL;
+    CComPtr<IPortableDeviceValues>  pValues;
+
+    // Get the Object Properties
+    hr = pParams->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES, &pValues);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES");
+
+    // Get Object Name from pValues
+    if (SUCCEEDED(hr))
+    {
+        hr = pValues->GetStringValue(WPD_OBJECT_NAME, &pszObjectName);
+        CHECK_HR(hr, "Failed to get WPD_OBJECT_NAME");
+    }
+
+    // Get the context map
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, &pContextMap);
+        CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Object data will be provided by the caller.  So Create a context identifying this
+        // creation request, since the actual data will come later, and the object can only be saved
+        // when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT call.
+        hr = CreateObjectManagementContext((ContextMap*) pContextMap, pszObjectName, pValues, false /*bUpdateRequest*/, &pszContext);
+        CHECK_HR(hr, "Failed to create object management context");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT, pszContext);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT");
+    }
+
+    // Set the optimal buffer size
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE, OPTIMAL_BUFFER_SIZE);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE value");
+    }
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszContext);
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszObjectName);
+
+    SAFE_RELEASE(pContextMap);
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_REVERT_OBJECT
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT: identifies the object creation request (driver returned this in
+ *          WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT).
+ *
+ *  The driver should:
+ *  - Free any resources associated with this context/operation.  The object should not be saved to the
+ *    device.  If a placeholder was created on the device for this operation, it should be removed.
+ */
+HRESULT WpdObjectManagement::OnRevert(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT     hr          = S_OK;
+    LPWSTR      pszContext  = NULL;
+    ContextMap*   pContextMap = NULL;
+
+    // There are no return parameters for this operation.
+    UNREFERENCED_PARAMETER(pResults);
+
+    hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT, &pszContext);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, (IUnknown**)&pContextMap);
+        CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = DestroyObjectManagementContext(pContextMap, pszContext);
+        CHECK_HR(hr, "Failed to revert object identified by context [%ws]", pszContext);
+    }
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszContext);
+
+    SAFE_RELEASE(pContextMap);
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT: identifies the object creation request (driver returned this in
+ *          WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT).
+ *
+ *  The driver should:
+ *  - Commit the object to the device.
+ *  - Return the new/updated ObjectID in WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID.
+ */
+HRESULT WpdObjectManagement::OnCommit(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT                     hr          = S_OK;
+    LPWSTR                      pszContext  = NULL;
+    ObjectManagementContext*    pContext    = NULL;
+    ContextMap*                 pContextMap = NULL;
+    CComPtr<IPortableDeviceValues> pEventParams;
+
+    hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT, &pszContext);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+
+    // Get the object management context for this request
+    if (SUCCEEDED(hr))
+    {
+        hr = GetClientContext(pParams, pszContext, (IUnknown**)&pContext);
+        CHECK_HR(hr, "Failed to get Object Management Context");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, (IUnknown**)&pContextMap);
+        CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        if (pContext->UpdateRequest)
+        {
+            // Update the object
+            hr = UpdateObject(pContext, pParams, pResults);
+        }
+        else
+        {
+            // Save the new object
+            hr = CommitNewObject(pContext, pszContext, pParams, pResults);
+        }            
+    }
+
+    // We're done with the context
+    SAFE_RELEASE(pContext);
+
+    // Destroy the context associated with this request, since it is no longer needed
+    if (SUCCEEDED(hr))
+    {
+        hr = DestroyObjectManagementContext(pContextMap, pszContext);
+        CHECK_HR(hr, "Failed to destroy object identified by context [%ws]", pszContext);
+    }
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszContext);
+
+    SAFE_RELEASE(pContextMap);
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_WRITE_OBJECT_DATA
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT: identifies the object creation request previsouly started with
+ *          WPD_PROPERTY_OBJECT_MANAGEMENT_CREATE_OBJECT.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE: specifies the next number of bytes to write.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_DATA: specifies byte array where the data should be copied from.
+ *
+ *  The driver should:
+ *  - Write the next WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE to the resource.
+ *  - Return the number of bytes actually written in WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_WRITTEN.
+ *    It is normally considered an error if this value does not match WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE.
+ */
+HRESULT WpdObjectManagement::OnWriteObjectData(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT                     hr                  = S_OK;
+    LPWSTR                      pszContext          = NULL;
+    DWORD                       dwNumBytesToWrite   = 0;
+    DWORD                       dwNumBytesWritten   = 0;
+    BYTE*                       pBuffer             = NULL;
+    DWORD                       cbBuffer            = 0;
+    ObjectManagementContext*    pContext            = NULL;
+
+    // Get the Context string
+    hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT, &pszContext);
+    CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT");
+
+    // Get the number of bytes to write
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE, &dwNumBytesToWrite);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE");
+    }
+
+    // Get the source buffer
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetBufferValue(WPD_PROPERTY_OBJECT_MANAGEMENT_DATA, &pBuffer, &cbBuffer);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_DATA");
+    }
+
+    // Get the resource context for this object creation request
+    if (SUCCEEDED(hr))
+    {
+        hr = GetClientContext(pParams, pszContext, (IUnknown**)&pContext);
+        CHECK_HR(hr, "Failed to get Object Management Context");
+    }
+
+    // Write the next band of data for this new object request
+    if (SUCCEEDED(hr))
+    {
+        // TBD:  Write bytes to object.  This sample driver ignores the data content.
+        dwNumBytesWritten = dwNumBytesToWrite;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_WRITTEN, dwNumBytesWritten);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_WRITTEN");
+    }
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pszContext);
+
+    // Free the memory.  CoTaskMemFree ignores NULLs so no need to check.
+    CoTaskMemFree(pBuffer);
+
+    SAFE_RELEASE(pContext);
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_UPDATE_OBJECT_WITH_PROPERTIES_AND_DATA
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID: Identifies the object to update.
+ *  - WPD_PROPERTY_OBJECT_MANAGEMENT_UPDATE_PROPERTIES: Contains an IPortableDeviceValues, describing
+ *      the updated properties of the object.  At the very least, it will contain:
+ *      -  WPD_OBJECT_SIZE: The total size of the object data stream.
+ *
+ *  The driver should:
+ *  - Create a context for this operation and return it in WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT.
+ *  - Return the optimal transfer buffer size in WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE.
+ */
+HRESULT WpdObjectManagement::OnUpdateObjectWithPropertiesAndData(
+    _In_    IPortableDeviceValues*  pParams,
+    _In_    IPortableDeviceValues*  pResults)
+{
+    HRESULT                         hr              = S_OK;
+    LPWSTR                          pszContext      = NULL;
+    LPWSTR                          pszObjectId     = NULL;
+    IUnknown*                       pContextMap     = NULL;
+    BOOL                            bUpdatable      = NULL;
+    CComPtr<IPortableDeviceValues>  pValues;
+
+    // Get the Object Identifier.  
+    hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID, &pszObjectId);
+    CHECK_HR(hr, "Failed to get WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+
+    // Get the Object Properties
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_MANAGEMENT_UPDATE_PROPERTIES, &pValues);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES");
+    }
+
+    // Get the context map
+    if (SUCCEEDED(hr))
+    {
+        hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, &pContextMap);
+        CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
+    }
+
+    // Validate whether this object supports the default resource
+    if (SUCCEEDED(hr))
+    {
+        hr = m_pFakeDevice->SupportsResource(pszObjectId, WPD_RESOURCE_DEFAULT, &bUpdatable);
+        CHECK_HR(hr, "Failed to check whether object supports WPD_RESOURCE_DEFAULT");
+
+        if (SUCCEEDED(hr) && !bUpdatable)
+        {
+            hr = E_INVALIDARG;
+            CHECK_HR(hr, "Object does not support WPD_RESOURCE_DEFAULT");
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Object data will be provided by the caller.  So Create a context identifying this
+        // creation request, since the actual data will come later, and the object can only be saved
+        // when we receive a WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT call.
+        hr = CreateObjectManagementContext((ContextMap*) pContextMap, pszObjectId, pValues, true /*bUpdateRequest*/, &pszContext);
+        CHECK_HR(hr, "Failed to create object management context");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT, pszContext);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT");
+    }
+
+    // Set the optimal buffer size
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE, OPTIMAL_BUFFER_SIZE);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE value");
+    }
+
+    CoTaskMemFree(pszContext);
+    CoTaskMemFree(pszObjectId);
+
+    SAFE_RELEASE(pContextMap);
+
+    return hr;
+}
+
+HRESULT WpdObjectManagement::CreateObjectManagementContext(
+    _In_    ContextMap*             pContextMap,
+    _In_    LPCWSTR                 pszObjectName,
+    _In_    IPortableDeviceValues*  pObjectProperties,
+    _In_    BOOL                    bUpdateRequest,
+    _Outptr_result_nullonfailure_   LPWSTR* ppszObjectManagementContext)
+{
+    HRESULT                     hr              = S_OK;
+    GUID                        guidContext     = GUID_NULL;
+    ObjectManagementContext*    pContext        = NULL;
+    CComBSTR    bstrContext;
+
+    if((pContextMap                 == NULL) ||
+       (pObjectProperties           == NULL) ||
+       (pszObjectName               == NULL) ||
+       (ppszObjectManagementContext == NULL))
+    {
+        hr = E_POINTER;
+        CHECK_HR(hr, "Cannot have NULL parameter");
+        return hr;
+    }
+
+    *ppszObjectManagementContext = NULL;
+
+    hr = CoCreateGuid(&guidContext);
+    if (SUCCEEDED(hr))
+    {
+        bstrContext = guidContext;
+        if(bstrContext.Length() == 0)
+        {
+            hr = E_OUTOFMEMORY;
+            CHECK_HR(hr, "Failed to create BSTR from GUID");
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        pContext = new ObjectManagementContext();
+        if(pContext != NULL)
+        {
+            CAtlStringW strKey = bstrContext;
+            pContext->Name              = pszObjectName;
+            pContext->ObjectProperties  = pObjectProperties;
+            pContext->UpdateRequest     = bUpdateRequest;
+
+            hr = pContextMap->Add(strKey, pContext);
+            CHECK_HR(hr, "Failed to add object creation context to client context map");
+
+            pContext->Release();
+        }
+        else
+        {
+            hr = E_OUTOFMEMORY;
+            CHECK_HR(hr, "Failed to allocate object creation context");
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        *ppszObjectManagementContext = AtlAllocTaskWideString(bstrContext);
+    }
+
+    return hr;
+}
+
+HRESULT WpdObjectManagement::DestroyObjectManagementContext(
+    _In_    ContextMap* pContextMap,
+    _In_    LPCWSTR     pszObjectManagementContext)
+{
+    HRESULT     hr  = S_OK;
+
+    CAtlStringW strKey = pszObjectManagementContext;
+    pContextMap->Remove(strKey);
+
+    return hr;
+}
+
+HRESULT WpdObjectManagement::CommitNewObject(
+    _In_    ObjectManagementContext*    pContext,
+    _In_    LPCWSTR                     pszContext,
+    _In_    IPortableDeviceValues*      pParams,
+    _In_    IPortableDeviceValues*      pResults)
+{
+    LPWSTR pszObjectID = NULL;
+
+    // Save the new object
+    HRESULT hr = m_pFakeDevice->SaveNewObject(pContext->ObjectProperties, &pszObjectID);
+    CHECK_HR(hr, "Failed to save new object [%ws] to device", pContext->Name);
+
+    // Let the caller know the new object's ID.
+    if (SUCCEEDED(hr))
+    {
+        hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID, pszObjectID);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Send the event
+        HRESULT hrTemp = S_OK;
+        CComPtr<IPortableDeviceValues> pEventParams;
+
+        // Get the object properties used for sending the event
+        hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pszObjectID, &pEventParams);
+        CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pszObjectID);
+
+        if (SUCCEEDED(hrTemp))
+        {
+            // Set the event-specific parameters
+            hrTemp = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_ADDED);
+            CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
+
+            hrTemp = pEventParams->SetStringValue(WPD_EVENT_PARAMETER_OBJECT_CREATION_COOKIE, pszContext);
+            CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_OBJECT_CREATION_COOKIE");
+            
+            // Send the Event
+            if (SUCCEEDED(hr))
+            {
+                PostWpdEvent(pParams, pEventParams);
+            }
+        }
+    }
+    
+    CoTaskMemFree(pszObjectID);
+
+    return hr;
+}
+
+HRESULT WpdObjectManagement::UpdateObject(
+    _In_    ObjectManagementContext*    pContext,
+    _In_    IPortableDeviceValues*      pParams,
+    _In_    IPortableDeviceValues*      pResults)
+{
+    // For convenience, the ObjectID was stored in Name for object updates
+    LPCWSTR pszObjectId = pContext->Name;
+    
+    // Update the object
+    HRESULT hr = m_pFakeDevice->UpdateContentObject(pszObjectId, pContext->ObjectProperties);
+    CHECK_HR(hr, "Failed to update object [%ws] to device", pszObjectId);
+
+    // Set the object ID.
+    if (hr == S_OK)
+    {
+        hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID, pszObjectId);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID");
+    }
+
+    if (hr == S_OK)
+    {
+        // Send the event
+        HRESULT hrTemp = S_OK;
+        CComPtr<IPortableDeviceValues> pEventParams;
+
+        // Get the object properties used for sending the event
+        hrTemp = m_pFakeDevice->GetObjectPropertiesForEvent(pContext->Name, &pEventParams);
+        CHECK_HR(hrTemp, "Failed to get properties for event on object %ws", pszObjectId);
+
+        if (hrTemp == S_OK)
+        {
+            // Set the event-specific parameters
+            hrTemp = pEventParams->SetGuidValue(WPD_EVENT_PARAMETER_EVENT_ID, WPD_EVENT_OBJECT_UPDATED);
+            CHECK_HR(hrTemp, "Failed to add WPD_EVENT_PARAMETER_EVENT_ID");
+
+            // Send the Event
+            if (hrTemp == S_OK)
+            {
+                PostWpdEvent(pParams, pEventParams);
+            }
+        }
+    }
+    
+    return hr;
+}